差分约束系统_差分约束和线性规划的区别-CSDN博客

本文链接：https://blog.csdn.net/ruoruo_cheng/article/details/52438653

差分约束系统是线性规划问题的一个特例。k行n列的线性规划矩阵 $A$ 的每一行包含一个1和一个-1，其余均为0。也就是说，每个约束条件都形如

x j - x i \leq b k

$x_j - x_i \le b_k$

单源最短路问题

这个问题可以从另一个角度来理解：给每个顶点 $v$ 分配一个顶标 $\delta(s, v)$ ，满足：
1. $\delta(s, v) \le \delta(s, u) + w(u, v), (u, v) \in E$
2. $存在(u, v) \in E，使得\delta(s, v) = \delta(s, u) + w(u, v)$

约束图

移项得

x j \leq b k + x i

$x_j \le b_k + x_i$

发现它和最短路问题中的三角不等式是一致的：

δ (s, v) \leq δ (s, u) + w (u, v), (u, v) \in E

$\delta(s, v) \le \delta(s, u) + w(u, v), (u, v) \in E$

由此，我们建图如下，得到差分约束系统的一组可行解或判其无解：
添加额外的源点 $v_0$ ，从 $v_0$ 向每个 $x_i$ 连一条有向边，边权为0。对于每个不等式 $x_j - x_i \le b_k$ ，连有向边 $(v_i, v_j)$ ， $w(v_i, v_j) = b_k$ 。求以 $v_0$ 为源点的单源最短路，如果存在负圈，则无解；否则， $x_i = \delta(s, v_i), 1 \le i \le n$ 是差分约束系统的一组可行解。

这样的一个图称为约束图。

无解

为什么存在负圈意味着差分约束系统无解呢？我们来证明一下。

设<script id="MathJax-Element-17" type="math/tex"> </script>是约束图中的一个负环， $v_1 = v_m$ 。相应地，差分约束系统中有不等式

x 2 - x 1 \leq w (v 1, v 2) x 3 - x 2 \leq w (v 2, v 3) . . . v m - v m - 1 \leq w (v m - 1, v m)

$x_2 - x_1 \le w(v_1, v_2)\\ x_3 - x_2 \le w(v_2, v_3)\\ ...\\ v_m - v_{m-1} \le w(v_{m-1}, v_m)$

全部加起来，有

0 \leq 一 个 负 数

$0 \le 一个负数$

这是不科学的。证毕。

转化

x j - x i \geq b k < = > x i - x j \leq - b k x j - x i < b k < = > x j - x i \leq b k - 1 x j - x i > b k < = > x i - x j \leq - b k + 1 x i = x j < = > x i \leq x j a n d x j \leq x i x i \leq b k < = > x i - 0 \leq b k

$x_j - x_i \ge b_k <=> x_i - x_j \le -b_k\\ x_j - x_i \lt b_k <=> x_j - x_i \le b_k - 1\\ x_j - x_i \gt b_k <=> x_i - x_j \le -b_k + 1\\ x_i = x_j <=> x_i \le x_j\ and\ x_j \le x_i\\ x_i \le b_k <=> x_i - 0 \le b_k$

解的特性

定理1：如果 $(x_1, x_2, ..., x_n)$ 是一组可行解，那么 $(x_1+d, x_2+d, ..., x_n+d)$ 也是一组可行解。
证明略。

定理2：由约束图得到的可行解满足 $x_i \le 0$ 。
证明略。

定理3：由约束图得到的可行解与其他满足 $x_i \le 0$ 的可行解相比，最大化 $\Sigma_{i=1}^nx_i$ 。
假设另有一组满足 $y_i \le 0$ 的可行解 $(y_0, y_1, y_2, ..., y_n)$ ，为了统一起见，同样附加一个 $y_0 = 0$ 。考察源点到任意一点，不妨设其为 $v_n$ ，最短路径为<script id="MathJax-Element-4537" type="math/tex"> </script>。 $x_0 \ge y_0$ 。假设 $x_i \ge y_i$ 成立，那么 $x_{i+1} = x_i + w(v_i, v_{i+1}) \ge y_i + w(v_i, v_{i+1}) \ge y_{i+1}$ 。第一个等号是根据最短路的性质。由数学归纳法，对于所有 $x_i$ ，均有 $x_i \ge y_i$ 成立，因而最大化了 $\Sigma_{i=1}^nx_i$ 。

UPDATE 2016.9.10
和WZH学长讨论有没有更直观的证法，受到启发，如下：
x、y还是和上面一样。从 $v_0$ 到 $v_n$ ，有

x n - x n - 1 = w (v n - 1, v n) x n - 1 - x n - 2 = w (v n - 2, v n - 1) . . . x 1 - x 0 = w (v 0, v 1)

$x_n - x_{n-1} = w(v_{n-1}, v_n)\\ x_{n-1} - x_{n-2} = w(v_{n-2}, v_{n-1})\\ ...\\ x_1 - x_0 = w(v_0, v_1)$
和

y n - y n - 1 \leq w (v n - 1, v n) y n - 1 - y n - 2 \leq w (v n - 2, v n - 1) . . . y 1 - y 0 \leq w (v 0, v 1)

$y_n - y_{n-1} \le w(v_{n-1}, v_n)\\ y_{n-1} - y_{n-2} \le w(v_{n-2}, v_{n-1})\\ ...\\ y_1 - y_0 \le w(v_0, v_1)$
分别全部相加，得

x n - x 0 = Σ w y n - y 0 \leq Σ w

$x_n - x_0 = \Sigma w\\ y_n - y_0 \le \Sigma w$
代入

x0=y0=0 $x_0 = y_0 = 0$ ，得

x n \geq y n

$x_n \ge y_n$
证毕。

定理4：由约束图得到的可行解最小化 $max\{x_i\} - min\{x_i\}$ 。
由定理1，我们可以“平移”解向量。这个变换不改变各个变量的相对大小。假设另有一组可行解 $(y_1, y_2, ..., y_n)$ ，将它平移，使得 $max\{y_i\} = max\{x_i\}$ 。由定理3的证明， $min\{x_i\} \ge min\{y_i\}$ ，故 $max\{x_i\} - min\{x_i\} \le max\{y_i\} - min\{y_i\}$ 。

如果我们要最小化 $\Sigma_{i=1}^nx_i$ ，最大化 $max\{x_i\} - min\{x_i\}$ ，该怎么做呢？

把最短路改为最长路即可。

怎么求最长路呢？一种方法是把所有边权取反，用SPFA求最短路。另一种方法是直接修改SPFA松弛的条件。注意这里的最长路与无权简单最长路的区别，所以它不是NP完全问题。

例题

Bzoj 2330 [SCOI2011]糖果

一开始TLE，上网搜索，得知这道题有两个坑：
1. 有一组数据是一条很长的链。不知道除了面向数据还有什么解决方法呢？
2. 有一组数据存在很大的负环。虽然这组数据存在负的自环，可以直接判掉……

关于负环的判定，我参考了lydrainbowcat的方法：记录最短路径的长度。

不良心的出题人。

#include <cstdio>
#include <queue>
#include <cctype>
#define NO_SOL() {puts("-1"); return 0;}
using namespace std;
typedef long long ll;
const int MAX_N = 100000, MAX_K = 100000;
int e_ptr = 1, n, k, head[MAX_N+1], d[MAX_N+1];
ll dis[MAX_N+1];
bool inq[MAX_N+1];
struct Edge {
    int v, next;
    ll w;
} E[MAX_K*2+1];
inline void add(int u, int v, ll w)
{
    E[e_ptr] = (Edge){v, head[u], w};
    head[u] = e_ptr++;
}

bool SPFA()
{
    queue<int> Q;

    for (int i = 1; i <= n; ++i) {
        inq[i] = true;
        dis[i] = -1;
        Q.push(i);
    }

    int u;
    while (!Q.empty()) {
        u = Q.front();
        Q.pop();
        inq[u] = false;
        for (int i = head[u]; i; i = E[i].next) {
            int v = E[i].v;
            ll upd = dis[u] + E[i].w;
            if (dis[v] > upd) {
                dis[v] = upd;
                d[v] = d[u] + 1;
                if (d[v] > n)
                    return false;
                if (!inq[v]) {
                    inq[v] = true;
                    Q.push(v);
                }
            }
        }
    }
    return true;
}

template<typename T>
inline void read(T& x)
{
    x = 0;
    char c = getchar();
    while (!isdigit(c))
        c = getchar();
    while (isdigit(c)) {
        x = x*10 + c - '0';
        c = getchar();
    }
}

int main()
{
    read(n);
    read(k);
    int x, a, b;
    for (int i = 0; i < k; ++i) {
        read(x);
        read(a);
        read(b);
        switch (x) {
            case 1: // a = b
            add(a, b, 0);
            add(b, a, 0);
            break;
            case 2: // a < b
            if (a == b)
                NO_SOL();
            add(a, b, -1);
            break;
            case 3: // a >= b
            add(b, a, 0);
            break;
            case 4: // a > b
            if (a == b)
                NO_SOL();
            add(b, a, -1);
            break;
            case 5: // a <= b
            add(a, b, 0);
        }
    }

    // 求最长路，边权取负后求最短路
    if (!SPFA())
        NO_SOL();
    ll ans = 0;
    for (int i = 1; i <= n; ++i)
        ans -= dis[i];
    printf("%lld\n", ans);
    return 0;
}