差分约束系统例题集

前一部分的算法讲解摘自原文：https://blog.csdn.net/consciousman/article/details/53812818 

差分约束系统

一、何为差分约束系统：

差分约束系统（system of difference constraints），是求解关于一组变数的特殊不等式组之方法。如果一个系统由n个变量和m个约束条件组成，其中每个约束条件形如xj-xi<=bk(i,j∈[1,n],k∈[1,m]),则称其为差分约束系统(system of difference constraints)。亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法。

通俗一点地说，差分约束系统就是一些不等式的组，而我们的目标是通过给定的约束不等式组求出最大值或者最小值或者差分约束系统是否有解。

比如：

二、差分约束系统的求解：

差分约束系统可以转化为图论来解决，对应于上面的不等式组，如果要求出x3-x0的最大值的话，叠加不等式可以推导出x3-x0<=7,最大值即为7，我们可以通过建立一个图，包含6个顶点，对每个xj-xi<=bk，建立一条i到j的有向边，权值为bk。通过求出这个图的x0到x3的最短路可以知道也为7，这是巧合吗？并不是。

之所以差分约束系统可以通过图论的最短路来解，是因为xj-xi<=bk，会发现它类似最短路中的三角不等式d[v] <=d[u]+w[u,v]，即d[v]-d[u]<=w[u,v]。而求取最大值的过程类似于最短路算法中的松弛过程。

三角不等式：（在此引用大牛的博客）

B - A <= c     (1)

C - B <= a     (2)

C - A <= b     (3)

 如果要求C-A的最大值，可以知道max（C-A）= min(b,a+c),而这正对应了下图中C到A的最短路。 

                                

因此，对三角不等式加以推广，变量n个，不等式m个，要求xn-x1的最大值，便就是求取建图后的最短路。

同样地，如果要求取差分约束系统中xn-x1的最小值，便是求取建图后的最长路。最长路可以通过spfa求出来，只需要改下松弛的方向即可，即if(d[v] < d[u] + dist(u,v)) d[v] = d[u] + dist(u,v)。当然我们可以把图中所有的边权取负，求取最短路，两者是等价的。

最长路求解算法证明如下：

http://www.cnblogs.com/g0feng/archive/2012/09/13/2683880.html

最后一点，建图后不一定存在最短路/最长路，因为可能存在无限减小/增大的负环/正环，题目一般会对应于不同的输出。判断差分约束系统是否存在解一般判环即可。

3、差分约束系统的应用

差分约束系统的应用很广，都会有一定的背景，我们只需要根据题意构造出差分约束系统，然后再根据题目的要求求解就行了。

一般题目会有三种情况：(1)、求取最短路 (2)、求取最长路 (3)、判断差分约束系统的解是否存在

当然这三种也可能会相互结合。

 

差分约束系统的解法如下：

1、  根据条件把题意通过变量组表达出来得到不等式组，注意要发掘出隐含的不等式，比如说前后两个变量之间隐含的不等式关系。

2、  进行建图：

首先根据题目的要求进行不等式组的标准化。

(1)、如果要求取最小值，那么求出最长路，那么将不等式全部化成xi – xj >= k的形式，这样建立j->i的边，权值为k的边，如果不等式组中有xi – xj > k，因为一般题目都是对整形变量的约束，化为xi – xj >= k+1即可，如果xi – xj = k呢，那么可以变为如下两个：xi – xj >= k, xi – xj <= k,进一步变为xj – xi >= -k，建立两条边即可。

(2)、如果求取的是最大值，那么求取最短路，将不等式全部化成xi – xj <= k的形式, 这样建立j->i的边，权值为k的边，如果像上面的两种情况，那么同样地标准化就行了。

(3)、如果要判断差分约束系统是否存在解，一般都是判断环，选择求最短路或者最长路求解都行，只是不等式标准化时候不同，判环地话，用spfa即可，n个点中如果同一个点入队超过n次，那么即存在环。

值得注意的一点是：建立的图可能不联通，我们只需要加入一个超级源点，比如说求取最长路时图不联通的话，我们只需要加入一个点S，对其他的每个点建立一条权值为0的边图就联通了，然后从S点开始进行spfa判环。最短路类似。

3、  建好图之后直接spfa或bellman-ford求解，不能用dijstra算法，因为一般存在负边，注意初始化的问题。

(1)、求取最小值

1、poj 1201- Intervals

题意：给定n个区间，[ai,bi]这个区间至少选选出ci个整数，求一个集合z，满足每个区间的要求，输出集合z的大小。
分析：令d[i]表示0到i这个区间内至少要选出d[i]个数，那么对于每个[ai,bi],有d[b] - d[ai-1] >= ci，同时隐含的一个条件是0 <= d[i] - d[i-1] <= 1,但是因此d[-1]不能表示，令d[i+1]示0到i这个区间内至少要选出d[i+1]个数，然后d[0] = 0,直接求取最长路就行了。
code:

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<cstring>
#include<queue>
using namespace std;
#define N 50005
const int inf = 0x3f3f3f3f;
struct ed {
	int to, wt, nex;
}a[N<<2];
int head[N];
int n, cnt = 0;
int dist[N], vis[N];
queue<int>q;
void add(int u, int v, int w) {
	a[cnt].to = v;
	a[cnt].wt = w;
	a[cnt].nex = head[u];
	head[u] = cnt++;
}
int spfa(int st, int en) {
	memset(vis, 0, sizeof(vis));
	memset(dist, -inf, sizeof(dist));
	dist[st] = 0;
	vis[st] = 1;
	q.push(st);
	while (!q.empty()) {
		int cmt = q.front();
		vis[cmt] = 0;
		q.pop();
		for (int i = head[cmt]; i != -1; i = a[i].nex) {
			int t = a[i].to;
			if (dist[t] < dist[cmt] + a[i].wt) {
				dist[t] = dist[cmt] + a[i].wt;
				if (!vis[t]) {
					vis[t] = 1;
					q.push(t);
				}
			}
		}
	}
	return dist[en];
}
int main() {
	memset(head, -1, sizeof(head));
	int mn = inf, mx = -1;
	int s, e, w;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d%d%d", &s, &e, &w);
		mn = min(s, mn);
		mx = max(e, mx);
		add(s, e+1, w);
	}
	mx++;
	for (int i = mn; i < mx; i++) {
		add(i, i + 1, 0);
		add(i + 1, i, -1);
	}
	cout << spfa(mn, mx) << endl;
	return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define N 50005
#define inf 0x3f3f3f
int n;
struct ed {
	int et;
	int wt;
}t;
vector<ed>mp[N];
int spfa(int h,int end) {
	int dist[N], cnt[N];
	memset(cnt, 0, sizeof(cnt));
	memset(dist, -inf, sizeof(dist));
	dist[h] = 0;
	cnt[h] = 1;
	queue<int>q;
	q.push(h);
	while (!q.empty()) {
		int cmt = q.front();
		q.pop();
		for (int i = 0; i < mp[cmt].size(); i++) {
			if (dist[mp[cmt][i].et] < dist[cmt] + mp[cmt][i].wt) {
				dist[mp[cmt][i].et] = dist[cmt] + mp[cmt][i].wt;
				q.push(mp[cmt][i].et);
			}
		}
	}
	return dist[end];
}
int main() {
	int s, e, w;
	int mx = -1, mn = inf;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d%d%d", &s, &e, &w);
		s += 1, e += 1;
		mn = min(mn, s);
		mx = max(mx, e);
		t.et = e;t.wt = w;
		mp[s-1].push_back(t);
	}
	for (int i = mn-1; i < mx; i++) {
		t.et = i + 1, t.wt = 0;
		mp[i].push_back(t);
		t.et = i, t.wt = -1;
		mp[i + 1].push_back(t);
	}
	cout << spfa(mn - 1, mx) << endl;
	return 0;
}

2、poj1275 - Cashier Employment

题意：在一家超市里，每个时刻都需要有营业员看管，R(i) (0 <= i < 24)表示从i时刻开始到i+1时刻结束需要的营业员的数目，现在有N(N <= 1000)个申请人申请这项工作，并且每个申请者都有一个起始工作时间 ti，如果第i个申请者被录用，那么他会从ti时刻开始连续工作8小时。现在要求选择一些申请者进行录用，使得任何一个时刻i，营业员数目都能大于等于R(i)。求出至少需要录用多少营业员。
分析：每天的工作情况都是一样的，我们只需要求出一天的即可。根据题意，令s[i]为一天内前i+1个小时录用的人数，如果i>=7,则s[i] - s[i-8] >= R[i],如果0 <= i < 7，则可以推出s[23] - s[i+16] + s[i] >= R[i]，同时每个时刻录用的人数有个上限，假设第i时刻最多可以录用的人数为b[i],则对于每一个i有0 <=s[i] - s[i-1] <= b[i]。
现在需要解决的一个问题是，第二个不等式中包含3个s组的变量，这该怎么建图呢？可以知道我们只需要枚举s[23]，那么这个量就是已知的了，因此不等式可以变为s[i] - s[i+16] >= R[i] - s[23],但是必须明白的一点是，既然s[23]是枚举的一天的录用人数的最小数目，我们建图之后求出的s[23]也应该为枚举的那个值，可以从0到n枚举s[23],第一个值便是答案，但是可以更高效地求解，因为问题具有单调性，直接二分.

因为s[-1] = 0,-1无法表示，只需要向右移动一个单位即可，那么令s[0] = 0，思路很清晰了，二分s[24]搜索最小值。
code:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;
#define N 1005
#define inf 0x3f3f3f
struct ed {
	int to, wt, next;
}a[N];
int t, n, cnt = 0;
int head[N];
int tim[25], fim[25];
void add(int u, int v, int w) {
	a[cnt].to = v;
	a[cnt].wt = w;
	a[cnt].next = head[u];
	head[u] = cnt++;
}
int dist[25], vis[25];
int spfa(int m) {
	memset(dist, -inf, sizeof(dist));
	memset(vis, 0, sizeof(vis));
	queue<int>q;
	dist[0] = 0;
	vis[0] = 1;
	q.push(0);
	while (!q.empty()) {
		int cmt = q.front();
		q.pop();
		if (cmt == 24 && dist[cmt] > m)return -1;
		vis[cmt] = 0;
		for (int i = head[cmt]; i != -1; i = a[i].next) {
			int ty = a[i].to;
			if (dist[ty] < dist[cmt] + a[i].wt) {
				dist[ty] = dist[cmt] + a[i].wt;
				if (!vis[ty]) {
				vis[ty]=1;
					q.push(ty);
				}
			}
		}
	}
	return dist[24];
}
int main() {
	int k;
	scanf("%d", &t);
	while (t--) {
		memset(fim, 0, sizeof(fim));
		for (int i = 0; i < 24; i++) 
			scanf("%d", &tim[i]);
		scanf("%d", &n);
		for (int i = 0; i < n; i++) {
			scanf("%d", &k);
			fim[k]++;
		}
		int l = -1, r = n+1;
		while (r-l>1) {
			//cout << r << " " << l << endl;
			cnt = 0;
			memset(head, -1, sizeof(head));
			int mid = (r + l) / 2;
			for (int i = 7; i < 24; i++) {
				add(i - 7, i + 1, tim[i]);
			}
			for (int i = 0; i < 24; i++) {
				add(i + 1, i, -fim[i]);
				add(i, i + 1, 0);
			}
			add(0, 24, mid); add(24, 0, -mid);
			for (int i = 0; i < 7; i++) {
				add(i + 17, i + 1, tim[i] - mid);
			}
			if (spfa(mid) == mid)
				r = mid;
			else
				l = mid;
		}
		l >= n ? cout << "No Solution" << endl : cout << r << endl;
	}
	return 0;
}

poj3169 - Layout
题意：有n头牛，他们按顺序排成了一排，有些牛关系比较好，他们的距离不能超过某个距离，还有些牛关系不好，他们之间的距离不能小于某个距离，可能会有多头牛挤在同一位置上，问1号牛和n号牛之间的最大距离是多少，如果不存在满足条件的排列则输出-1，如果距离无限大则输出-2.

分析：令d[i]表示第i头牛的位置，因为牛按顺序排列，则有d[i] <= d[i+1],关系好的牛有d[a] +D >= d[b], 关系不好的牛有d[a] + d <= d[b]，把不等式标准化之后直接跑最短路即可。

如果无限大则输出-2，不存在排列输出-1.
 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;
#define N 1005
const int inf = 0x3f3f3f3f;
struct ed {
	int to, wt, next;
}a[20*N];
int head[N], dis[N], vis[N], ct[N];
int n, ml, md;
int cnt = 0;
void add(int u, int v, int w) {
	a[cnt].to = v;
	a[cnt].wt = w;
	a[cnt].next = head[u];
	head[u] = cnt++;
}
queue<int>q;
int spfa() {
	memset(ct, 0, sizeof(ct));
	memset(vis, 0, sizeof(vis));
	for (int i = 1; i <= n; i++)
		dis[i] = inf;
	dis[1] = 0;
	q.push(1);
	ct[1] = 1;
	while (!q.empty()) {
		int cmt = q.front();
		q.pop();
		vis[cmt] = 0;
		for (int i = head[cmt]; i != -1; i = a[i].next) {
			int t = a[i].to;
			if(dis[t]>dis[cmt]+a[i].wt){
				dis[t] = dis[cmt] + a[i].wt;
				if (!vis[t]) {
					vis[t] = 1;q.push(t);
					if (++ct[t] > n)return -1;
				}
			}
		}
	}
	return dis[n] == inf ? -2 : dis[n];
}
int main() {
	memset(head, -1, sizeof(head));
	int a, b, d;
	scanf("%d%d%d", &n, &ml, &md);
	for (int i = 0; i < ml; i++) {
		scanf("%d%d%d", &a, &b, &d);
		add(a, b, d);
	}
	for (int i = 0; i < md; i++) {
		scanf("%d%d%d", &a, &b, &d);
		add(b, a, -d);
	}
	cout << spfa() << endl;
	return 0;
}

poj1364 - KIng

题意： 给定一个序列a1, a2, ..., an，给出它的一些子序列以及对该子序列的约束条件，例如asi, asi+1, asi+2, ..., asi+ni，且asi＋asi+1＋asi+2＋......＋asi+ni 小于或者大于 ki。求是否存在满足以上要求的数列。是 则输出“lamentable kingdom”,否则输出“successful conspiracy”。

分析：判断解是否存在只要判正环就行了，很明显，题目需要从区间和下手，令S[i]为1到i这i个元素的和，那么根据题意建立不等式然后建图，s[si+ni] - s[si-1] > k,或者s[si+ni] - s[si-1] < k最后加入一个源点，然后对每个点i建立一条权为0的边.如果不存在环则解一定存在。当然求最短路判负环也可以。
 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;
#define N 1005
int n, m, cnt;
const int inf = 0x3f3f3f3f;
struct ed {
	int to, wt, next;
}a[N];
int dis[N], head[N], ct[N], vis[N];
void add(int u, int v, string oi, int k) {
	if (oi == "gt") {
		a[cnt].to = u;
		a[cnt].wt = -(k + 1);
		a[cnt].next = head[v];
		head[v] = cnt++;
	}
	else {
		a[cnt].to = v;
		a[cnt].wt = k-1;
		a[cnt].next = head[u];
		head[u] = cnt++;
	}
}
queue<int>q;
bool spfa(int s) {
	for (int i = 0; i < s; i++)
		dis[i] = inf;
	memset(vis, 0, sizeof(vis));
	memset(ct, 0, sizeof(ct));
	dis[s] = 0;
	ct[s] = 1;
	q.push(s);
	while (!q.empty()) {
		int cmt = q.front();
		q.pop();
		//cout << cmt << endl;
		vis[cmt] = 0;
		for (int i = head[cmt]; i != -1; i = a[i].next) {
			int t = a[i].to;
			if (dis[t] > dis[cmt] + a[i].wt) {
				dis[t] = dis[cmt] + a[i].wt;
				if (!vis[t]) {
					q.push(t);
					vis[t] = 1;
					if (++ct[t] > s+1)
						return false;
				}
			}
		}
	}
	return true;
}
int main() {
	int si, ki, ni;
	string oi;
	while (~scanf("%d", &n) && n != 0) {
		cnt = 0;
		memset(head, -1, sizeof(head));
		scanf("%d", &m);
		for (int i = 0; i < m; i++) {
			cin >> si >> ni >> oi >> ki;
			add(si - 1, si + ni, oi, ki);
		}
		for (int i = 0; i <= n; i++) {
			a[cnt].to = i;
			a[cnt].wt = 0;
			a[cnt].next = head[n+1];
			head[n+1] = cnt++;
		}
		if (spfa(n+1)) 
			cout << "lamentable kingdom" << endl;
		else
			cout << "successful conspiracy" << endl;
	}
	return 0;
}

poj2983 - Is the Information Reliable?
题意：银河系中有n个防御站排成一条直线，给定m条信息，每条信息的格式如下。
P A B X代表A站在B站北方X光年处。
V A B 代表A站在B站北方，而且距离至少为1光年。
问是否存在这样的一个防御战排列满足上述要求，是输出Reliable，否输出 Unreliable。
分析：同上题一样，令d[i]表示第i号防御站的位置，根据信息建立不等式，然后根据选择的判环方式建边，然后加入源点s，对每个点建立一条长为0的边。直接spfa判环即可。
 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;
int n, m, cnt;
#define N 1015
const int inf = 0x3f3f3f3f;
int head[N], vis[N], ct[N], dis[N];
queue<int>q;
struct se {
	int to, wt, next;
}re[101010];
void add(int u, int v, int w) {
	re[cnt].to = v;
	re[cnt].wt = w;
	re[cnt].next = head[u];
	head[u] = cnt++;
}
bool spfa() {
	for (int i = 0; i <= n; i++) {
		dis[i] = -inf;
		vis[i] = 0;
		ct[i] = 0;
	}
	while (!q.empty())
		q.pop();
	q.push(0);
	dis[0] = 0;
	ct[0] = 1;
	while (!q.empty()) {
		int cmt = q.front();
		q.pop();
		vis[cmt] = 0;
		for (int i = head[cmt]; i != -1; i = re[i].next) {
			int t = re[i].to;
			if (dis[t] < dis[cmt] + re[i].wt) {
				dis[t] = dis[cmt] + re[i].wt;
				if (!vis[t]) {
					vis[t] = 1;
					q.push(t);
					if (++ct[t] > n) {
						return false;
					}
				}
			}
		}
	}
	return true;
}
int main() {
	int a, b, k;
	char g;
	while (~scanf("%d%d", &n, &m)) {
		cnt = 0;
		memset(head, -1, sizeof(head));
		for (int i = 0; i < m; i++) {
			cin.get();
			cin >> g >> a >> b;
			//cout << g << a << b;
			if (g == 'P') {
				scanf("%d", &k);
				add(a, b, k);
				add(b, a, -k);
			}
			else {
				add(a, b, 1);
			}
		}
		for (int i = 1; i <= n; i++) 
			add(0, i, 0);
		if (spfa())
			cout << "Reliable" << endl;
		else
			cout << "Unreliable" << endl;
	}
	return 0;
}