差分约束系统 2016.11.10

参考：http://baike.baidu.com/view/1008149.htm

http://blog.youkuaiyun.com/kalilili/article/details/43484765

一、概述

如果一个系统由 n 个变量和 m 个约束条件组成，形成 m 个形如 xi - xj ≤ k 的不等式(i, j ∈ [1, n], k为常数)，则称其为差分约束系统（system of difference constraints）

亦即，差分约束系统是求解关于一组变量的特殊不等式组的方法

二、求解

求解差分约束系统，可以转化成图论的单源最短路径（或最长路径）问题

在最短路中，我们用 dis[u] 和 dis[v] 表示从源点到 u 和 v 的最短路径的权值之和，w[u, v] 表示 u->v 这条边的权值

显然有 dis[v] <= dis[u] + w[u, v] 即 dis[v] - dis[u] <= w[u, v]

观察发现上式与差分约束系统中不等式类似

于是我们可以把差分约束系统转化为一张图

例如：

有不等式组

x1 - x2 ≤  0
x1 - x5 ≤ -1
x2 - x5 ≤  1
x3 - x1 ≤  5
x4 - x1 ≤  4
x4 - x3 ≤ -1
x5 - x3 ≤  3
x5 - x4 ≤ -3

把所有的不等式都转化为图中的一条边，对于约束条件 xi - xj ≤ k 即 xi ≤ xj + k ，以变量 xi、xj 为结点 vi，vj，连接一条边 vj->vi，边权为 k

我们再增加一个源点 v0，v0 与所有结点相连，边权均为 0

于是不等式组中又增加了下列不等式：
x1 - x0 ≤ 0
x2 - x0 ≤ 0
x3 - x0 ≤ 0
x4 - x0 ≤ 0
x5 - x0 ≤ 0

最后形成的如下所示的一张图：

现在以 v0 为源点，求单源最短路径。最终得到的 v0 到 vn 的最短路径长度就是 xn 的一个解

由图可知，这组解为 {-5, -3, 0, -1, -4}

如果有一组解 {x1, x2, ..., xn} 存在，那么对于任意一个常数 k，{x1 + k, x2 + k, ..., xn + k} 这组解肯定也是存在的

因为对于每个约束条件 xi - xj ≤ k，xi 和 xj 同时加上或减去一个数后仍然成立

所以这个不等式组要么无解，否则有无数组解

如果从源点到某个结点不存在最短路径，也就是说图中存在负权环，不等式组无解

三、

HDU 1531 King

参考：http://www.cnblogs.com/wally/p/3228581.html

首先吐槽一下题面，写这么长而且下标还有毒...给跪了

设 sum[i] = a[1] + a[2] + …… + a[i]，于是有 a[si] + a[si + 1] + ... + a[si + ni] = sum[si + ni] - sum[si - 1]

从而有 sum[si + ni] - sum[si - 1] > ki 或者 sum[si + ni] - sum[si - 1] < ki

将不等式变形为差分约束系统中不等式的形式　sum[si-1] - sum[si+ni] ≤ -ki - 1, sum[si + ni] - sum[si - 1] ≤ ki - 1

建图跑最短路判断是否有负权环就可以了

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <ctime>
#include <cctype>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pair;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 100 + 10;

int head[maxn], to[2 * maxn], Next[2 * maxn], val[2 * maxn];
int n, m, si, ni, ki, edge = 0;
char oi[10];
int dis[maxn], cnt[maxn];
bool vis[maxn];

void init(void);
void add_edge(int u, int v, int _val);
bool spfa(int s);

int main() {
#ifdef Floyd
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d", &n) != EOF && n != 0) {
        init();
        scanf("%d", &m);
        while (m--) {
            scanf("%d %d %s %d", &si, &ni, oi, &ki);
            if (oi[0] == 'g') {
                add_edge(si + ni, si - 1, -ki - 1);
            } else {
                add_edge(si - 1, si + ni, ki - 1);
            }
        }
        int s = n + 1;
        for (int i = 0; i <= n; ++i) {
            add_edge(s, i, 0);
        }
        if (spfa(s)) {
            printf("lamentable kingdom\n");
        } else {
            printf("successful conspiracy\n");
        }
    }
    return 0;
}

bool spfa(int s) {
    memset(vis, false, sizeof(vis));
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i <= n + 1; ++i) {
        dis[i] = INF;
    }
    dis[s] = 0;
    queue<int> q; q.push(s);
    while (!q.empty()) {
        int f = q.front(); q.pop();
        vis[f] = false; cnt[f]++;
        if (cnt[f] > n + 1) { return false; }
        for (int i = head[f]; i != -1; i = Next[i]) {
            int v = to[i], w = val[i];
            if (dis[v] > dis[f] + w) {
                dis[v] = dis[f] + w;
                if (!vis[v]) { vis[v] = true; q.push(v); }
            }
        }
    }
    return true;
}

void init(void) {
    memset(head, -1, sizeof(head));
    edge = 0;
}

void add_edge(int u, int v, int _val) {
    to[edge] = v; val[edge] = _val; Next[edge] = head[u]; head[u] = edge++;
}

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <ctime>
#include <cctype>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pair;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 200 + 10;

struct Edge {
    int u, v, val;
};

Edge edge[maxn];
int n, m, si, ni, ki, cnt = 0;
char oi[10];
int dis[maxn];

void add_edge(int u, int v, int val);
bool bellman_ford(int s);

int main() {
#ifdef Floyd
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d", &n) != EOF && n != 0) {
        cnt = 0;
        scanf("%d", &m);
        while (m--) {
            scanf("%d %d %s %d", &si, &ni, oi, &ki);
            if (oi[0] == 'g') {
                add_edge(si + ni, si - 1, -ki - 1);
            } else {
                add_edge(si - 1, si + ni, ki - 1);
            }
        }
        int s = n + 1;
        for (int i = 0; i <= n; ++i) {
            add_edge(s, i, 0);
        }
        if (bellman_ford(s)) {
            printf("lamentable kingdom\n");
        } else {
            printf("successful conspiracy\n");
        }
    }
    return 0;
}

bool bellman_ford(int s) {
    for (int i = 0; i <= n + 1; ++i) {
        dis[i] = INF;
    }
    dis[s] = 0;
    for (int i = 0; i <= n; ++i) {
        bool flag = false;
        for (int j = 0; j < cnt; ++j) {
            int u = edge[j].u, v = edge[j].v, val = edge[j].val;
            if (dis[v] > dis[u] + val) { dis[v] = dis[u] + val; flag = true; }
        }
        if (!flag) {
            break;
        }
    }
    for (int j = 0; j < cnt; ++j) {
        int u = edge[j].u, v = edge[j].v, val = edge[j].val;
        if (dis[v] > dis[u] + val) { return false; }
    }
    return true;
}

void add_edge(int u, int v, int val) {
    edge[cnt].u = u, edge[cnt].v = v, edge[cnt++].val = val;
}

COGS 286 [NOI1999] 01串

参考：https://www.byvoid.com/blog/noi-1999-solution/

解题思路：

定义 sum[i] 为串的前 i 位之和，显然有 s[i] = sum[i] - sum[i-1]
根据 sum 的意义，我们可以很容易得出约束条件 0 <= sum[i] - sum[i-1] <= 1　①
当 i >= L1 时，从 s[i-L1+1] 至 s[i]，长度为 L1 的子串，其中 1 的个数为 sum[i] - sum[i-L1]
根据题中条件，应满足 A1 <= C[i] - C[i-L1] <= B1 ②
同样的，当 i>=L0，从 s[i-L0+1] 至 s[i]，长度为 L0 的子串，其中 0 的个数为 L0 - (sum[i] - sum[i-L1])
应满足 A0 <= L0 - (sum[i] - sum[i-L1]) <= A1 ③
由上述 ① ② ③ 3 个不等式，可以得出

•     sum[i]    - sum[i-1]    <= 1      (1<=i<=N)
•     sum[i-1]  - sum[i]      <= 0      (1<=i<=N)
•     sum[i-L1] - sum[i]      <= -A1    (i-L1>=0)
•     sum[i]    - sum[i-L1]   <= B1     (i-L1>=0)
•     sum[i]    - sum[i-L0]   <= L0-A0  (i-L0>=0)
•     sum[i-L0] - sum[i]      <= B0-L0  (i-L0>=0)

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <ctime>
#include <cctype>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pair;

const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 1000 + 10;

int head[maxn], Next[6 * maxn], to[6 * maxn], val[6 * maxn];
int edge = 0, N, A0, B0, L0, A1, B1, L1;
int dis[maxn], cnt[maxn];
bool vis[maxn];

void add_edge(int u, int v, int _val);
bool spfa(void);

int main() {
    freopen("sequence.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
    scanf("%d %d %d %d %d %d %d", &N, &A0, &B0, &L0, &A1, &B1, &L1);
    memset(head, -1, sizeof(head));
    edge = 0;
    for (int i = L0; i <= N; ++i) {
        add_edge(i, i - L0, B0 - L0); add_edge(i - L0, i, L0 - A0);
    }
    for (int i = L1; i <= N; ++i) {
        add_edge(i, i - L1, -A1); add_edge(i - L1, i, B1);
    }
    for (int i = 1; i <= N; ++i) {
        add_edge(i, i - 1, 0); add_edge(i - 1, i, 1);
    }
    if (spfa()) {
        for (int i = 1; i <= N; ++i) {
            printf("%d", dis[i] - dis[i - 1]);
        }
        printf("\n");
    } else {
        printf("-1\n");
    }
    return 0;
}

void add_edge(int u, int v, int _val) {
    to[edge] = v; val[edge] = _val; Next[edge] = head[u]; head[u] = edge++;
}

bool spfa(void) {
    memset(vis, false, sizeof(vis));
    memset(cnt, 0, sizeof(cnt));
    for (int i = 1; i <= N; ++i) {
        dis[i] = INF;
    }
    dis[0] = 0;
    queue<int> q; q.push(0);
    while (!q.empty()) {
        int f = q.front(); q.pop();
        vis[f] = false; ++cnt[f];
        if (cnt[f] > N) {
            return false;
        }
        for (int i = head[f]; i != -1; i = Next[i]) {
            int v = to[i], w = val[i];
            if (dis[v] > dis[f] + w) {
                dis[v] = dis[f] + w;
                if (!vis[v]) { vis[v] = true; q.push(v); }
            }
        }
    }
    return true;
}

3、HDU 3666 THE MATRIX PROBLEM

参考：http://www.cnblogs.com/acSzz/archive/2012/10/17/2728073.html

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <cctype>
#include <vector>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> Pair;

const int mod = 1e9 + 7;
const int INF = 0x7fffffff;
const int maxn = 400 + 10;

int N, M, edge, s = 1;
double L, U;
int head[2 * maxn], cnt[2 * maxn], Next[2 * maxn * maxn], to[2 * maxn * maxn];
double val[2 * maxn * maxn];
double C[maxn][maxn];
bool vis[2 * maxn];
double dis[2 * maxn];

void init(void);
void add_edge(int u, int v, double _val);
bool spfa(void);

int main() {
#ifdef Floyd
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d %d %lf %lf", &N, &M, &L, &U) != EOF) {
        double L_t = log(L), U_t = log(U);
        init();
        for (int i = 1; i <= N; ++i) {
            for (int j = 1; j <= M; ++j) {
                scanf("%lf", &C[i][j]);
                double t = log(C[i][j]);
                add_edge(i, j + N, -L_t + t); add_edge(j + N, i, U_t - t);
            }
        }
        if (spfa()) {
            printf("YES\n");
        } else {
            printf("NO\n");
        }
    }
    return 0;
}

void init(void) {
    memset(head, -1, sizeof(head));
    edge = 0;
}

void add_edge(int u, int v, double _val) {
    to[edge] = v; val[edge] = _val; Next[edge] = head[u]; head[u] = edge++;
}

bool spfa(void) {
    memset(vis, false, sizeof(vis));
    memset(cnt, 0, sizeof(cnt));
    dis[s] = 0.0;
    for (int i = 2; i <= N + M; ++i) { dis[i] = 1.0 * INF; }
    queue<int> q; q.push(s);
    while (!q.empty()) {
        int f = q.front(); q.pop();
        vis[f] = false; ++cnt[f];
        if (cnt[f] > (int)sqrt(1.0 * (N + M))) { return false; }
        for (int i = head[f]; i != -1; i = Next[i]) {
            int v = to[i];
            double w = val[i];
            if (dis[v] > dis[f] + w) {
                dis[v] = dis[f] + w;
                if (!vis[v]) { vis[v] = true; q.push(v); }
            }
        }
    }
    return true;
}