差分约束系统:
如果一个系统由n个变量和m个约束条件组成,其中每个约束条件形如xj-xi<=bk(i,j∈[1,n],k∈[1,m]),则称其为差分约束系统(system of difference constraints)。亦即,差分约束系统是求解关于一组变量的特殊不等式组的方法。
差分约束可以转化话单源最短路求解。因为单源最短路径满足三角不等式d[v] <= d[u] + w(u, v), 这里的 <= 可以为改 >= 只要改变一下初始化条件即可。
差分约束题目有两种,一种求最大值,另外一种求最小值。
(1)当题目是求满足给定不等式的最小值时,就是求图的最长路。
建图方式如下:a – b >= c,对应于边b –> a w(b, a) = c, 然后求最短路;判断条件是:d[v] <= d[u] + w(u, v), 初始化d[]为-INF. 这样求出的d[]就是满足条件的最小值。原因很简单,因为d[i] 是从-INF开始增大,根据不等式逐渐增大,当满足所有不等式时,那么d[i]肯定是最小的了。
(2)当题目是求满足给定不等式的最大值时,就是求图的最短路。
建图方式如下:a – b <= c,对应于边b –> a w(b, a) = c, 然后求最长路;判断条件是:d[v] >= d[u] + w(u, v), 初始化d[]为INF.这样求出的d[]就是最大值。原因和上面一样,因为是从INF逐渐减小的,当满足完所有条件时,就停止。那么d[i]是最大的了。
常见单源最短路径方法有bellman_ford, spfa, Dijkstra
bellman_ford算法,适用于边值负权的图,还能判断是否存在负权回路,它是把所有的边都松弛n-1次。算法复杂度为O(VE),这个方法效率不高,在数据规模大时,往往会TLM。
spfa算法,是bellman_ford算法的改进版。它通过一个队列或栈,来保存需要更新的顶点。它减去了bellman算法很多不必要的松弛,因此它的效率比bellman要好,为O(ke)。
Dijkstra算法,它只适用于边值为非负的图上。它基于贪心,每次选取最短的边。可以用heap来优化,在正权图也可以考虑。
体会:虽然bellman_ford不及spfa的效率,但它在判断是否存在负权回路比spfa方便。它能判断不连通的图,而spfa判断不连通图时有可能不准确,当开始的源点到达不了某些顶点时,那么那些顶点就无法检验了。为此,spfa需要添加一个超源点来使得图连通(还有一个方法:就是先把所有顶点入队),而bellman不需要添加超源点, 因为它是对图的每一条边都进行n-1次松弛。有时候超源点不好添加,这时可以考虑用bellman。
还有一点,当适用spfa添加超源点使得图连通(超源点S0 到其他顶点距离都为0)时,用最短路求出的解, 除了满足给定的不等式外,还会满足下列的不等式:
S1 – S0 <= 0
S2 – S0 <= 0
…
Sn – S0 <= 0
也就是说S1 ~ Sn是 < 0 的,这个对不同问题,要具体分析。这些额外满足的不等式,不能与题目要求的矛盾。
SPFA判负圈需要图联通,所以要加个超源点连上所有的点。而Bellman判负圈是对每一条边进行松弛,可以直接判。
SPFA code:
- /* **********************************************
- Author : JayYe
- Created Time: 2013/10/7 15:26:16
- File Name : Orz.cpp
- *********************************************** */
- #include <stdio.h>
- #include <string.h>
- #include <algorithm>
- using namespace std;
- const int maxn = 100 + 5;
- const int INF = 1<<30;
- struct Edge{
- int u, to, next, val;
- }edge[maxn*maxn];
- int head[maxn], d[maxn], vis[maxn], T[maxn], q[maxn*maxn], n, E;
- void init() {
- memset(head, -1, sizeof(head));
- E = 0;
- }
- void newedge(int u, int to, int val) {
- edge[E].u = u;
- edge[E].to = to;
- edge[E].val = val;
- edge[E].next = head[u];
- head[u] = E++;
- }
- bool SPFA() {
- for(int i = 0;i <= n + 1; i++) {
- d[i] = INF; vis[i] = T[i] = 0;
- }
- T[n+1] = 1;
- d[n+1] = 0;
- vis[n+1] = 1;
- int st = 0, ed = 0;
- q[ed++] = n+1;
- while(st < ed) {
- int u = q[st++];
- vis[u] = 0;
- for(int i = head[u];i != -1;i = edge[i].next) {
- int to = edge[i].to, val = edge[i].val;
- if(d[to] > d[u] + val) {
- d[to] = d[u] + val;
- if(!vis[to]) {
- vis[to] = 1;
- T[to]++;
- if(T[to] > n + 1) return true;
- q[ed++] = to;
- }
- }
- }
- }
- return false;
- }
- int main() {
- int m;
- while(scanf("%d", &n) != -1 && n) {
- init();
- scanf("%d", &m);
- for(int i = 0;i < m; i++) {
- int fr, len, k;
- char op[4];
- scanf("%d%d%s%d", &fr, &len, op, &k);
- int u = fr + len, to = fr-1;
- if(op[0] == 'g')
- newedge(u, to, -1 - k);
- else
- newedge(to, u, k - 1);
- }
- for(int i = 0;i <= n; i++) newedge(n+1, i, 0);
- printf("%s\n", SPFA() ? "successful conspiracy" : "lamentable kingdom");
- }
- return 0;
- }
Bellman code:
- /* **********************************************
- Author : JayYe
- Created Time: 2013/10/7 15:26:16
- File Name : Orz.cpp
- *********************************************** */
- #include <stdio.h>
- #include <string.h>
- #include <algorithm>
- using namespace std;
- const int maxn = 100 + 5;
- struct Edge{
- int u, to, next, val;
- }edge[maxn*maxn*2];
- int head[maxn], d[maxn], n, E;
- void init() {
- memset(head, -1, sizeof(head));
- E = 0;
- }
- void newedge(int u, int to, int val) {
- edge[E].u = u;
- edge[E].to = to;
- edge[E].val = val;
- edge[E].next = head[u];
- head[u] = E++;
- }
- bool Bellman() {
- memset(d, 0, sizeof(d));
- for(int i = 0;i < n+1; i++) {
- for(int j = 0;j < E; j++) {
- int u = edge[j].u, to = edge[j].to, val = edge[j].val;
- if(d[to] > d[u] + val) {
- d[to] = d[u] + val;
- if(i == n) return true;
- }
- }
- }
- return false;
- }
- int main() {
- int m;
- while(scanf("%d", &n) != -1 && n) {
- init();
- scanf("%d", &m);
- for(int i = 0;i < m; i++) {
- int fr, len, k;
- char op[4];
- scanf("%d%d%s%d", &fr, &len, op, &k);
- int u = fr + len, to = fr-1;
- if(op[0] == 'g')
- newedge(u, to, - 1 - k);
- else
- newedge(to, u, k - 1);
- }
- printf("%s\n", Bellman() ? "successful conspiracy" : "lamentable kingdom");
- }
- return 0;
- }