差分约束系统例题详解

差分约束系统例题详解

例1：pku1364

已知一个序列a[1], a[2], ......, a[n]，给出它的若干子序列以及对该子序列的约束条件，例如a[si], a[si+1], a[si+2], ......, a[si+ni]，且a[si]＋a[si+1]＋a[si+2]＋......＋a[si+ni] < or > ki。问题关键在于如何转化约束条件，开始我想以序列中的每一个值做一个点，如a[1], a[2] ……，就发现他们的关系是多者之间的关系，跟差分系统对不上，在看到MickJack的讲解后，才知道，用前n项和来转化成两两之间的关系。

如：s[a] + s[a+1] + …… + s[b] < c 可以转化成前n项和sum[b] - sum[a - 1] < c，为了能用Bellman_Ford,即将< 转化成<= ，sum[b] - sum[a - 1] <= c - 1。

我用Bellman_Ford写的：

#include

#define INF 0xfffffff

#define NN 104

int index, n;

int dis[NN];

struct node{

int s, e, v;

}edge[NN];

void add(int a, int b, int c){

edge[index].s = a;

edge[index].e = b;

edge[index].v = c;

index++;

}

void Init(int s){

int i;

for (i = 0; i <= n; i++){

dis[i] = INF;

}

dis[s] = 0;

}

void Relax(int s, int e, int v){

if (dis[e] > dis[s] + v){

dis[e] = dis[s] + v;

}

}

/*查找负边权回路，1表示存在*/

int Bellman_Ford(){

Init(0);

int i, j;

for (i = 1; i <= n; i++){

for (j = 0; j < index; j++){

Relax(edge[j].s, edge[j].e, edge[j].v);

}

}

for (j = 0; j < index; j++){

if (dis[edge[j].e] > dis[edge[j].s] + edge[j].v){

return 1;

}

}

return 0;

}

int main()

{

char str[4];

int a, b, c, m;

while (scanf("%d", &n) != EOF){

if (n == 0) break;

scanf("%d", &m);

index = 0;

while (m--){

scanf("%d%d%s%d", &a, &b, str, &c);

if (str[0] == 'l'){

add(a - 1, a + b, c - 1); // c-1 使得< 变成<= 就能够判负环了

}else{

add(a + b, a - 1, -c - 1);

}

}

if(Bellman_Ford()) puts("successful conspiracy");

else puts("lamentable kingdom");

}

return 0;

}

做这题时，我用重新学习了下Bellman_Ford，感觉这个写的挺不错的。

为了锻炼一下，我又写了个SPFA，错了好次才过。

差分系统跟最短路还是有点区别的，就是得附加一个源点，使得他与所有点都相连，边权赋为零，这样才能保证连通，这一题我就错这个地方了。开始写Bellman_Ford的时候没注意，没有加点也过了，后来发现SPFA就过不了，想了想，还是有道理的，bellman是对边操作，不加源点，照样能对任意一条边松弛，而SPFA就不一样，是对点操作，通过点，对与之相连的边进行松弛，就必须得附加源点了，不过有种方法可以不加，SPFA时，将所有点先入队，或将邻接表的根节点入队。总结了以下关键点。

key1：做SPFA时，最好用邻接表存储，才能达到效果。

key2：为了不增加源点，将所有邻接表的根节点入队。

key3：为了减少队列队内存的负担，用循环队列实现，手动模拟更快，以前都是每向下一层，更新一次队列，现在是用循环，当队列满时更新队列，队列长度要大于队列一次可能保存的最多节点，这里就是节点的总个数，最多n+1个点同时都在队里，因为有mark 数组的限制，这里队列长度我取了n+2。

key4：当任意一节点入队次数超过|V|次的时候，即可判断有负权回路。

#include

#include

#define INF 0xfffffff

#define NN 106

int index, n;

int dis[NN]; /* 保存到源点距离，在这里没有设源，没有含义*/

int root[NN]; /* root[i] 找到与i节点相连的第一条后继边*/

int mark[NN]; /* 标记是否已入队*/

int next[NN]; /* 邻接的下一个定点*/

int cnt[NN]; /* 保存节点入队次数*/

struct node{

int e, v;

}edge[NN];

void add(int a, int b, int c){

int head, tmp;

edge[index].e = b;

edge[index].v = c;

head = root[a];

//key1

if (head == -1){

root[a] = index;

}else{

tmp = head;

while (next[tmp] != -1){

tmp = next[tmp];

}

next[tmp] = index;

}

next[index] = -1;

index++;

}

void Init(){

int i;

for (i = 0; i <= n; i++){

dis[i] = INF;

}

}

/*查找负边权回路，1表示存在*/

int Spfa(){

int i, len, cur, tmp, head, nxt;

int que[NN];

Init();

len = 0;

//key2

for (i = 0; i <= n; i++){

if (root[i] != -1){

que[len++] = i;

cnt[i] = 1;

mark[i] = 1;

}

}

//key3

for (i = 0; i != len; i = (i + 1) % (n + 2)){

cur = que[i];

head = root[cur];

tmp = head;

while (tmp != -1){

nxt = edge[tmp].e;

if (dis[nxt] > dis[cur] + edge[tmp].v){

dis[nxt] = dis[cur] + edge[tmp].v;

if (!mark[nxt]){

mark[nxt] = 1;

cnt[nxt]++;

que[len] = nxt;

len = (len + 1) % (n + 2);

//key4

if (cnt[nxt] > n + 1) return 1;

}

}

tmp = next[tmp];

}

mark[cur] = 0;

}

return 0;

}

int main()

{

char str[4];

int a, b, c, m;

while (scanf("%d", &n) != EOF){

if (n == 0) break;

scanf("%d", &m);

index = 0;

memset(root, -1, sizeof(root));

while (m--){

scanf("%d%d%s%d", &a, &b, str, &c);

if (str[0] == 'l'){

add(a - 1, a + b, c - 1);

}else{

add(a + b, a - 1, -c - 1);

}

}

memset(cnt, 0, sizeof(cnt));

memset(mark, 0, sizeof(mark));

if(Spfa()) puts("successful conspiracy");

else puts("lamentable kingdom");

}

return 0;

}

例2：pku3159（SPFA + 栈）

小孩A认为小孩B比自己多出的最多不会超过c个糖果，也就是B - A <= c，正好符合差分约束方程，就是A到B的边权w(A, B) = c;用SPFA + 栈能过。

这里有两种加边方式：

第一种：我以前用的，用这个超时了，因为每次加边都是将边夹在邻接表的最后面，需要一个查找时间，这题数据量大，自然就超时了。

void add(int a, int b, int c){

int tmp;

edge[edNum].e = b;

edge[edNum].v = c;

next[edNum] = -1;

tmp = root[a];

if (tmp == -1){

root[a] = edNum;

}else{

while (next[tmp] != -1){

tmp = next[tmp];

}

next[tmp] = edNum;

}

edNum++;

}

第二种：这种我刚学到的，比较好，每次把边加在最前面，突然想起sjr有一道题的加边方法和这个一样，那时怎么就看不懂，大概是不懂邻接表的缘故吧。

void add(int a, int b, int c){

edge[edNum].e = b;

edge[edNum].v = c;

next[edNum] = root[a];

root[a] = edNum++;

}

这题还得用栈实现，用队列超时，我开始用队列，一直TLE，我这里写了两个，Spfa()是用队列实现的，Spfa1是用栈实现的。

#include

#include

#include

#define INF 0xfffffff

#define MM 150004

#define NN 30004

int edNum, N;

struct node{

int e, v;

}edge[MM];

int next[MM];

int dis[NN];

int root[NN];

int que[NN];

int mark[NN];

int stack[NN];

void add(int a, int b, int c){

int tmp;

edge[edNum].e = b;

edge[edNum].v = c;

next[edNum] = root[a];

root[a] = edNum++;

}

void Spfa()

{

int i, quNum, tmp, nxt, cur;

for (i = 1; i <= N; i++){

dis[i] = INF;

}

dis[1] = 0;

quNum = 0;

for (i = 1; i <= N; i++){

if (root[i] != -1){

que[quNum++] = i;

mark[i] = 1;

}

}

for (i = 0; i != quNum; i = (i + 1) % (N + 1)){

cur = que[i];

tmp = root[cur];

while (tmp != -1){

nxt = edge[tmp].e;

if (dis[nxt] > dis[cur] + edge[tmp].v){

dis[nxt] = dis[cur] + edge[tmp].v;

if (!mark[nxt]){

mark[nxt] = 1;

que[quNum] = nxt;

quNum = (quNum + 1) % (N + 1);

}

}

tmp = next[tmp];

}

mark[cur] = 0;

}

}

void Spfa1()

{

int i, top, tmp, nxt, cur;

for (i = 1; i <= N; i++){

dis[i] = INF;

}

dis[1] = 0;

top = 0;

for (i = 1; i <= N; i++){

if (root[i] != -1){

stack[++top] = i;

mark[i] = 1;

}

}

while (top){

cur = stack[top--];

tmp = root[cur];

mark[cur] = 0;

while (tmp != -1){

nxt = edge[tmp].e;

if (dis[nxt] > dis[cur] + edge[tmp].v){

dis[nxt] = dis[cur] + edge[tmp].v;

if (!mark[nxt]){

mark[nxt] = 1;

stack[++top] = nxt;

}

}

tmp = next[tmp];

}

}

}

int main()

{

int M, a, b, c, i;

scanf("%d%d", &N, &M);

edNum = 0;

for (i = 0; i <= N; i++){

root[i] = -1;

mark[i] = 0;

}

while (M--){

scanf("%d%d%d", &a, &b, &c);

add(a, b, c);

}

Spfa1();

printf("%d\n", dis[N]);

//system("pause");

return 0;

}

例3：pku2983(SPFA + 栈)

分析题意：

输入有两种形式：

1：P A B X 即B + X = A 转化一下：B - A <= -X, A - B <= X 构造边和权：(A, B, -X)，(B, A, X)

2：V A B 即 B +１<= A 转化一下：B - A <= -1 构造边和权：(A, B, -1) WA了无数次，终于过了，不是SPFA的原因，是自己没写好啊！！每次写Bellman_Ford 的时候挺简单，写SPFA的时候就死活不过，一度让我怀疑，SPFA是不是不稳定！！不过还都是因为自己不过小心，处理的时候很容易出错。不过SPFA还是很快的，422ms，Bellman_Ford就跑了2907ms，跟没过也差不多了！

#include

#include

#define INF 0xfffffff

#define NN 1004

#define MM 200004

int edNum, N;

int next[MM];

int root[NN];

int mark[NN];

int cnt[NN];

int dis[NN];

int stack[NN];

struct node{

int e, v;

}edge[MM];

void add(int a, int b, int c){

edge[edNum].e = b;

edge[edNum].v = c;

next[edNum] = root[a];

root[a] = edNum++;

}

int Spfa()

{

int i, top, cur, tmp, nxt;

top = 0;

//初始化的时候没有加源点，直接将所有有根的点入栈，也很不错for (i = 1; i <= N; i++){

dis[i] = INF;

// key1

if (root[i] != -1){

stack[++top] = i;

cnt[i]++;

mark[i] = 1;

}

}

while (top){

cur = stack[top--];

tmp = root[cur];

mark[cur] = 0;

while (tmp != -1){

nxt = edge[tmp].e;

//key2

if (dis[nxt] > dis[cur] + edge[tmp].v){

dis[nxt] = dis[cur] + edge[tmp].v;

if (!mark[nxt]){

cnt[nxt]++;

if (cnt[nxt] > N + 1){

return 1;

}

mark[nxt] = 1;

stack[++top] = nxt;

}

}

tmp = next[tmp];

}

}

return 0;

}

int main()

{

int i, a, b, c, M;

char str[2];

while (scanf("%d%d", &N, &M) != EOF)

{

edNum = 0;

for (i = 0; i <= N; i++){

root[i] = -1;

mark[i] = 0;

cnt[i] = 0;

}

while (M--){

scanf("%s%d%d", str, &a, &b);

if (str[0] == 'P'){

scanf("%d", &c);

add(b, a, c);

add(a, b, -c);

}else{

add(a, b, -1);

}

}

if (Spfa()){

puts("Unreliable");

}else{

puts("Reliable");

}

}

return 0;

}

例4：pku3169

这题还是用的SPFA + 栈过的，400多ms，写得多了，发现都可以套用模块了，除了输入不太一样外，其他的都基本一样。

模块一：负责各个数组的初始化

模块二：负责加边，对边用邻接表处理

模块三：SPFA 用栈来实现的过程

#include

#include

#define INF 0xfffffff

#define NN 1004

#define MM 20004

int edNum, N;

int next[MM];

int root[NN];

int mark[NN];

int cnt[NN];

int dis[NN];

int stack[NN];

struct node{

int e, v;

}edge[MM];

/*在这里我用了一个函数来完成初始化，也可以看着一个固定模块了*/

/*模块一*/

void Init(){

int i;

for (i = 0; i <= N; i++){

root[i] = -1;

mark[i] = 0;

cnt[i] = 0;

}

}

/*模块二*/

edge[edNum].e = b;

edge[edNum].v = c;

next[edNum] = root[a];

root[a] = edNum++;

}

/*函数返回-1，表示有负边权回路，就表示不可能

函数返回-2，就表示起点到终点的距离不定，这里用dis[N] == INF，来判断，因为开始就是赋值的是INF

否者，返回dis[N]，这里面存的就是起点到终点的最大距离

*/

/*模块三*/

int Spfa()

{

int i, top, cur, tmp, nxt;

top = 0;

for (i = 1; i <= N; i++){

dis[i] = INF;

if (root[i] != -1){

stack[++top] = i;

cnt[i]++;

mark[i] = 1;

}

}

dis[1] = 0;

while (top){

cur = stack[top--];

tmp = root[cur];

mark[cur] = 0;

while (tmp != -1){

nxt = edge[tmp].e;

if (dis[nxt] > dis[cur] + edge[tmp].v){

dis[nxt] = dis[cur] + edge[tmp].v;

if (!mark[nxt]){

cnt[nxt]++;

if (cnt[nxt] > N + 1){

return -1;

}

mark[nxt] = 1;

stack[++top] = nxt;

}

}

tmp = next[tmp];

}

}

if (dis[N] == INF){

return -2;

}

return dis[N];

}

int main()

{

int ML, MD, a, b, c;

scanf("%d%d%d", &N, &ML, &MD);

Init();

while (ML--){

scanf("%d%d%d", &a, &b, &c);

}

while (MD--){

scanf("%d%d%d", &a, &b, &c);

add(b, a, -c);

}

printf("%d\n", Spfa());

//system("pause");

return 0;

}

例5：pku1201

这题依然SPFA + 栈过！

不同的是，这题有隐含条件，而且所求也大不一样。

由于这是对区间操作，求至少包含区间[ai, bi]中ci个点的最小集合。可以用集合元素个数来定义变量，即num[bi] - num[ai] >= ci, 但有个隐含条件就是，每个元素都是整点，取得话，最多为一，最少为0, 即num[i+1] - num[i] <= 1, num[i+1] - num[i] >= 0, 将这些条件再转换成最短路里的边和权，就可以做了。

这里求得是至少，也就是最小值，即num[maxn] - num[0] >= ans, 我们要转化成<= 号，也就是num[0] - num[maxn] <= -ans, 这样就行了，赋初值时，令dis[maxn] = 0，求得就是每个点到maxn的距离了，输出结果就是dis[0]加个负号。

#include

#include

#define INF 0xfffffff

#define NN 50004

#define MM 150004

int edNum, maxn;

int mark[NN];

int root[NN];

int dis[NN];

int next[MM];

int stack[NN];

struct node{

int e, v;

}edge[MM];

void Init(){

int i;

for (i = 0; i < NN; i++){

mark[i] = 0;

root[i] = -1;

dis[i] = INF;

}

}

void add(int a, int b, int c){

edge[edNum].e = b;

edge[edNum].v = c;

next[edNum] = root[a];

root[a] = edNum++;

}

void Spfa()

{

int i, cur, nxt, tmp, top = 0;

for (i = 0; i <= maxn; i++){

if (root[i] != -1){

stack[++top] = i;

mark[i] = 1;

}

}

// 这里需要注意，要将终点置零，求的就是别的点到终点maxn的距离dis[maxn] = 0;

while (top){

cur = stack[top--];

mark[cur] = 0;

tmp = root[cur];

while (tmp != -1){

nxt = edge[tmp].e;

if (dis[nxt] > dis[cur] + edge[tmp].v){

dis[nxt] = dis[cur] + edge[tmp].v;

if (!mark[nxt]){

mark[nxt] = 1;

stack[++top] = nxt;

}

}

tmp = next[tmp];

}

}

}

int main()

{

int n, i, a, b, c;

scanf("%d", &n);

maxn = 0;

edNum = 0;

Init();

for (i = 1; i <= n; i++){

scanf("%d%d%d", &a, &b, &c);

add(b + 1, a, -c);

if (b + 1 > maxn){

maxn = b + 1;

}

}

for (i = 0; i <= maxn; i++){

add(i + 1, i, 0);

add(i, i + 1, 1);

}

Spfa();

//输出的时候也要注意，是起点到终点的距离的负值

printf("%d\n", -dis[0]);

// system("pause");

return 0;

}