【图论】差分约束

原创于 2025-08-24 11:15:04 发布 · 684 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#图论 #算法 #c++

ACM 专栏收录该内容

42 篇文章

订阅专栏

1. 基本概念

差分约束系统（Difference Constraints System）是一类特殊的线性不等式组，形式为：

$xi−xj≤ckx_i - x_j \leq c_k$
$xi−xj≥ckx_i - x_j \geq c_k$
$x_i - x_j = c_k$

其中 $x_i$ 是变量， $c_k$ 是常数。

2. 核心思想

将不等式转化为图论中的最短路径问题：

每个变量 $x_i$ 对应图中的一个节点
每个不等式 $xi−xj≤ckx_i - x_j \leq c_k$ 对应一条从 $j$ 到 $i$ 的边，权值为 $c_k$
系统有解 $⇔\Leftrightarrow$ 图中无负环

3. 不等式转化规则

原始不等式	转化形式	对应边
$xi−xj≤cx_i - x_j \leq c$	$xi≤xj+cx_i \leq x_j + c$	$\xrightarrow{c} i$
$xi−xj≥cx_i - x_j \geq c$	$xj≤xi−cx_j \leq x_i - c$	$\xrightarrow{-c} j$
$x_i - x_j = c$	$xi≤xj+cx_i \leq x_j + c$ 且 $xj≤xi−cx_j \leq x_i - c$	$\xrightarrow{c} i$ 和 $\xrightarrow{-c} j$

4. 经典问题类型

4.1 求可行解

判断系统是否有解，若有则给出一组解。

4.2 求最大/最小值

求 $x_n - x_1$ 的最大值 $⇒\Rightarrow$ 求 $x_1$ 到 $x_n$ 的最短路径
求 $x_n - x_1$ 的最小值 $⇒\Rightarrow$ 求 $x_1$ 到 $x_n$ 的最长路径

5. 算法实现

5.1 Bellman-Ford算法

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;

struct Edge {
    int u, v, w;
    Edge(int _u, int _v, int _w) : u(_u), v(_v), w(_w) {}
};

class DifferenceConstraints {
private:
    int n; // 变量数量
    vector<Edge> edges;
    vector<int> dist;
    vector<int> inQueue;
    vector<int> count;
    
public:
    DifferenceConstraints(int _n) : n(_n) {
        dist.resize(n + 1, INT_MAX);
        inQueue.resize(n + 1, false);
        count.resize(n + 1, 0);
    }
    
    // 添加约束: x[u] - x[v] <= w
    void addConstraint(int u, int v, int w) {
        edges.emplace_back(v, u, w); // v -> u, weight = w
    }
    
    // 添加约束: x[u] - x[v] >= w
    void addConstraintGE(int u, int v, int w) {
        edges.emplace_back(u, v, -w); // u -> v, weight = -w
    }
    
    // 添加约束: x[u] - x[v] = w
    void addConstraintEQ(int u, int v, int w) {
        addConstraint(u, v, w);
        addConstraint(v, u, -w);
    }
    
    // 添加源点，连接到所有点，距离为0
    void addSource(int source) {
        for (int i = 1; i <= n; i++) {
            if (i != source) {
                edges.emplace_back(source, i, 0);
            }
        }
    }
    
    // SPFA算法检测负环
    bool solve() {
        queue<int> q;
        int source = 0; // 虚拟源点
        
        // 添加虚拟源点到所有点的边
        for (int i = 1; i <= n; i++) {
            edges.emplace_back(source, i, 0);
        }
        
        dist[source] = 0;
        q.push(source);
        inQueue[source] = true;
        
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            inQueue[u] = false;
            
            for (const Edge& e : edges) {
                if (e.u == u && dist[u] != INT_MAX) {
                    int v = e.v;
                    int w = e.w;
                    
                    if (dist[v] > dist[u] + w) {
                        dist[v] = dist[u] + w;
                        
                        if (!inQueue[v]) {
                            q.push(v);
                            inQueue[v] = true;
                            count[v]++;
                            
                            // 检测负环
                            if (count[v] > n) {
                                return false; // 存在负环，无解
                            }
                        }
                    }
                }
            }
        }
        
        return true; // 无负环，有解
    }
    
    // 获取变量值
    int getValue(int var) {
        return dist[var];
    }
    
    // 获取两点间最大差值
    int getMaxDifference(int u, int v) {
        if (dist[u] == INT_MAX || dist[v] == INT_MAX) return INT_MAX;
        return dist[v] - dist[u];
    }
};

// 示例使用
int main() {
    // 问题：x1 - x2 <= 2, x2 - x3 <= 1, x1 - x3 <= 4
    // 求 x1 - x3 的最大值
    
    DifferenceConstraints dc(3);
    
    dc.addConstraint(1, 2, 2);  // x1 - x2 <= 2
    dc.addConstraint(2, 3, 1);  // x2 - x3 <= 1  
    dc.addConstraint(1, 3, 4);  // x1 - x3 <= 4
    
    if (dc.solve()) {
        cout << "系统有解" << endl;
        cout << "x1 - x3 的最大值: " << dc.getMaxDifference(3, 1) << endl;
        
        // 输出各变量值
        for (int i = 1; i <= 3; i++) {
            cout << "x" << i << " = " << dc.getValue(i) << endl;
        }
    } else {
        cout << "系统无解（存在负环）" << endl;
    }
    
    return 0;
}

5.2 Floyd-Warshall算法（适用于小规模）

// 适用于变量较少的情况
bool solveFloyd(vector<vector<int>>& graph, int n) {
    // 初始化距离矩阵
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (graph[i][k] != INT_MAX && graph[k][j] != INT_MAX) {
                    graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j]);
                }
            }
        }
    }
    
    // 检查对角线是否有负值（负环）
    for (int i = 1; i <= n; i++) {
        if (graph[i][i] < 0) return false;
    }
    
    return true;
}