差分约束系统-POJ-1364

参考：http://hi.baidu.com/yacbi/blog/item/e79fa42e56a9ff3e1e3089ee .html

所谓查分约束系统其实很简单，就是全都是两个未知数的差小于等于某个常数（大于等于

也可以，因为左右乘以-1就可以化成小于等于）的一系列方程组（ax《=p，a=1或-1）。如：

X1 - X2 <= 0

X1 - X5 <= -1

X2 - X5 <= 3

X3 - X2 <= 5

X4 - X3<= 4

X4 - X3 <= -12

X5 - X1 <= -23

X5 - X4 <= -3

这样的不等式组就称作差分约束系统。

这个不等式组要么无解，要么就有无数组解。因为如果有一组解{X1, X2, ..., Xn}

的话，那么对于任何一个常数k，{X1 + k, X2 + k, ..., Xn + k}肯定也是一组解，因

为任何两个数同时加一个数或减去一个数之后，它们的差是不变的。

差分约束系统，就是求出满足简单线性不等式组xj-xi<=bk的解。而我们在求这个问题时

可以将他转化为图问题来解决，将各个未知数看成图的顶点，而右边的常数看成两个顶点

的边权值，比如：将xi-xj<=k转换为xi<=xj+k,看成xj指向xi的有向边，权值为k，这样求

方程组的解就相当于求各个顶点到源点的最短距离，而哪里来的源点？

很简单，我们加上一个点作为源点，并且为了始源点能够到达每一个顶点，将源点和顶点

间的距离设为某个常数如0。并且只有图中存在负权环时，方程组才无解，否则一定有解。

而对可以判断图是否有负权环且可以求单源最短距离算法中首选bellman-ford。这样查分约束

系统问题就解决了。当然有个问题那就是查分约束系统不可以求解<(>)的问题,所以我们必须

将其转化为<=(>=)的问题。

题目大意就是：

　　给定一个序列的长度，然后给定若干关系：这个关系是子序列各个元素之和与某个给定整数的大小关系。要求是否存在这样一个序列满足所有给定的若干关系。

本题主要就是需要想到利用前n个元素的和为替代，即设s[i] = a[1] + a[2] + …a[i]。

则a[si] + a[si+1] + … + a[si + ni] = s[si + ni] - s[si - 1]；所以如果a[si] + a[si+1] + … + a[si + ni] < k 则 s[si + ni] - s[si - 1] < k <= k - 1；如果a[si] + a[si+1] + … + a[si + ni] > k 则 s[si - 1] - s[si + ni] < -k <= -k - 1；

下面就是查分约束系统了。

A：spfa

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<queue>

#include<stack>

#include<map>

#include<algorithm>

using namespace std;

const int maxn=20002;

const int MAXM=1000009;

const int inf=999999999;

int n,m;

struct Edge

{

    int v,w,next;

}edge[1003];

int first[203];

int e;

void addedge(int u,int v,int w)

{

    printf("addedge[%d,%d,%d]\n",u,v,w);

    edge[e].v=v;edge[e].w=w;

    edge[e].next=first[u];

    first[u]=e++;

}

int s[203];

int vis[203];

int cnt[203];

int d[203];

int top;

bool spfa()

{

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

    {

        addedge(n+1,i,0);

        //addedge(i,n+1,0);

    }//建立无穷源点n+1,若是非联通图可使之成为联通图

    for(int i=0;i<=n+1;i++)

    {

        d[i]=inf;

        vis[i]=0;

    }

    s[++top]=n+1;

    d[n+1]=0;

    while(top>-1)

    {

        int x=s[top--];

        vis[x]=0;

        printf("shitshit       =         %d\n",x);

        for(int k=first[x];k!=-1;k=edge[k].next)

        {

            if(d[edge[k].v]>d[x]+edge[k].w)

            {

                d[edge[k].v]=d[x]+edge[k].w;

                if(!vis[edge[k].v])

                {

                    vis[edge[k].v]=1;

                    if(++cnt[edge[k].v]>n)

                        return false;//若一个点入队次数超过n，则必然存在负权回路

                    s[++top]=edge[k].v;

                }

            }

        }

    }

    return true;

}

int main()

{

    freopen("in.txt","r",stdin);

    while(scanf("%d",&n),n)

    {

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

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

        scanf("%d",&m);

        int s,len,t;

        char c[3];

        e=0;

        top=-1;

        for(int i=0;i<m;i++)

        {

            scanf("%d %d %s %d",&s,&len,c,&t);

            if(c[0]=='g')

                addedge(s+len,s-1,-t-1);//将大于关系转换为<=关系

            else

                addedge(s-1,s+len,t-1);

        }

        if(!spfa())

        {

            puts("successful conspiracy");

        }

        else

        {

            puts("lamentable kingdom");

        }

    }

}

B:bellman-ford

#include <iostream>

#include <cstdio>

#include <algorithm>

#include <cmath>

#include <string>

#include <set>

#include <queue>

using namespace std;

#define MAXN 120

#define NIL 0x7fffffff/2

struct egde

{

    int u, s, d;

}E[MAXN];

int d[MAXN];

bool bell_ford (int n, int m)

{

        int i, k;

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

                d[i] = NIL;

        d[0] = 0;

        for(k=0; k<n; k++)

        {

                for(i=0; i<m; i++)

                {

                        if(d[E[i].u] == NIL)

                            continue;

                        if(d[E[i].u] + E[i].d < d[E[i].s])

                                d[E[i].s] = d[E[i].u] + E[i].d;

                }

        }

        for(i=0; i<m; i++)

        {

                if(d[E[i].u] + E[i].d < d[E[i].s])

                        return 0;   //如果第 n 次还未更新完，说明存在负环

        }

        return 1;

}

int main()

{

    freopen("in.txt","r",stdin);

    int n, m, i, len, j, cal, k;

    string c;

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

    {

        scanf("%d", &m);

        for(k=0; k<m; k++)

        {

            scanf("%d %d", &i, &len);

            cin >> c;

            scanf("%d", &cal);

            j = i + len + 1;

            if(c == "gt")

                E[k].u = i, E[k].s = j, E[k].d = -cal - 1;

            else

                E[k].u = j, E[k].s = i, E[k].d = cal - 1;

        }

        for(i=1, k=m; i<=n+1; i++, k++)

            E[k].u = 0, E[k].s = i, E[k].d = 0;

        bool ans = bell_ford (n+1, m+n+1);

        if(ans)

            printf("lamentable kingdom\n");

        else

            printf("successful conspiracy\n");

    }

    return 0;

}