POJ3169 Layout （差分约束）

Layout

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 10022		Accepted: 4807

Description

Like everyone else, cows like to stand close to their friends when queuing for feed. FJ has N (2 <= N <= 1,000) cows numbered 1..N standing along a straight line waiting for feed. The cows are standing in the same order as they are numbered, and since they can be rather pushy, it is possible that two or more cows can line up at exactly the same location (that is, if we think of each cow as being located at some coordinate on a number line, then it is possible for two or more cows to share the same coordinate). 

Some cows like each other and want to be within a certain distance of each other in line. Some really dislike each other and want to be separated by at least a certain distance. A list of ML (1 <= ML <= 10,000) constraints describes which cows like each other and the maximum distance by which they may be separated; a subsequent list of MD constraints (1 <= MD <= 10,000) tells which cows dislike each other and the minimum distance by which they must be separated. 

Your job is to compute, if possible, the maximum possible distance between cow 1 and cow N that satisfies the distance constraints.

Input

Line 1: Three space-separated integers: N, ML, and MD. 

Lines 2..ML+1: Each line contains three space-separated positive integers: A, B, and D, with 1 <= A < B <= N. Cows A and B must be at most D (1 <= D <= 1,000,000) apart. 

Lines ML+2..ML+MD+1: Each line contains three space-separated positive integers: A, B, and D, with 1 <= A < B <= N. Cows A and B must be at least D (1 <= D <= 1,000,000) apart.

Output

Line 1: A single integer. If no line-up is possible, output -1. If cows 1 and N can be arbitrarily far apart, output -2. Otherwise output the greatest possible distance between cows 1 and N.

Sample Input

4 2 1
1 3 10
2 4 20
2 3 3

Sample Output

27

Hint

Explanation of the sample: 

There are 4 cows. Cows #1 and #3 must be no more than 10 units apart, cows #2 and #4 must be no more than 20 units apart, and cows #2 and #3 dislike each other and must be no fewer than 3 units apart. 

The best layout, in terms of coordinates on a number line, is to put cow #1 at 0, cow #2 at 7, cow #3 at 10, and cow #4 at 27.

题目大意：N头牛按编号1—N排成一排，其中有一些牛之间的距离不能超过某个值，还有一些牛之间的距离不能少于某个值，问第一头牛与第N头牛之间的最大距离是多少。若无解，输出-1；若距离无限大，输出-2；否则，输出最大距离。

对差分约束的相关描述如下

三、差分约束

      1、数形结合

      介绍完最短路，回到之前提到的那个不等式组的问题上来，我们将它更加系统化。

      如若一个系统由n个变量和m个不等式组成，并且这m个不等式对应的系数矩阵中每一行有且仅有一个1和-1，其它的都为0，这样的系统称为差分约束( difference constraints )系统。引例中的不等式组可以表示成如图三-1-1的系数矩阵。

图三-1-1

      然后继续回到单个不等式上来，观察 x[i] - x[j] <= a[k]， 将这个不等式稍稍变形，将x[j]移到不等式右边，则有x[i] <= x[j] + a[k]，然后我们令a[k] = w(j, i)，再将不等式中的i和j变量替换掉，i = v， j = u，将x数组的名字改成d（以上都是等价变换，不会改变原有不等式的性质），则原先的不等式变成了以下形式：d[u] + w(u, v) >= d[v]。

      这时候联想到SPFA中的一个松弛操作：

     if (d[u]  +  w(u, v)  <  d[v]) {
        d[v]  =  d[u]  +  w(u, v);
    }

      对比上面的不等式，两个不等式的不等号正好相反，但是再仔细一想，其实它们的逻辑是一致的，因为SPFA的松弛操作是在满足小于的情况下进行松弛，力求达到d[u] + w(u, v) >= d[v]，而我们之前令a[k] = w(j, i)，所以我们可以将每个不等式转化成图上的有向边：

      对于每个不等式 x[i] - x[j] <= a[k]，对结点 j 和 i 建立一条 j -> i的有向边，边权为a[k]，求x[n-1] - x[0] 的最大值就是求 0 到n-1的最短路。

图三-1-2

      图三-1-2 展示了 图三-1-1的不等式组转化后的图。

      2、三角不等式

      如果还没有完全理解，我们可以先来看一个简单的情况，如下三个不等式：

B - A <= c      (1)

C - B <= a      (2)

C - A <= b      (3)

      我们想要知道C - A的最大值，通过(1) + (2)，可以得到 C - A <= a + c，所以这个问题其实就是求min{b, a+c}。 将上面的三个不等式按照  三-1 数形结合 中提到的方式建图，如图三-2-1所示。

图三-2-1

      我们发现min{b, a+c}正好对应了A到C的最短路，而这三个不等式就是著名的三角不等式。将三个不等式推广到m个，变量推广到n个，就变成了n个点m条边的最短路问题了。

      3、解的存在性

      上文提到最短路的时候，会出现负权圈或者根本就不可达的情况，所以在不等式组转化的图上也有可能出现上述情况，先来看负权圈的情况，如图三-3-1，下图为5个变量5个不等式转化后的图，需要求得是X[t] - X[s]的最大值，可以转化成求s到t的最短路，但是路径中出现负权圈，则表示最短路无限小，即不存在最短路，那么在不等式上的表现即X[t] - X[s] <= T中的T无限小，得出的结论就是 X[t] - X[s]的最大值 不存在。

图三-3-1

      再来看另一种情况，即从起点s无法到达t的情况，如图三-3-2，表明X[t]和X[s]之间并没有约束关系，这种情况下X[t] - X[s]的最大值是无限大，这就表明了X[t]和X[s]的取值有无限多种。

图三-3-2

      在实际问题中这两种情况会让你给出不同的输出。综上所述，差分约束系统的解有三种情况：1、有解；2、无解；3、无限多解；

      4、最大值 => 最小值

      然后，我们将问题进行一个简单的转化，将原先的"<="变成">="，转化后的不等式如下：

B - A >= c      (1)

C - B >= a      (2)

C - A >= b      (3)

      然后求C - A的最小值，类比之前的方法，需要求的其实是max{b, c+a}，于是对应的是图三-2-1从A到C的最长路。同样可以推广到n个变量m个不等式的情况。

      

      5、不等式标准化

      如果给出的不等式有"<="也有">="，又该如何解决呢？很明显，首先需要关注最后的问题是什么，如果需要求的是两个变量差的最大值，那么需要将所有不等式转变成"<="的形式，建图后求最短路；相反，如果需要求的是两个变量差的最小值，那么需要将所有不等式转化成">="，建图后求最长路。

      如果有形如：A - B = c 这样的 等式呢？我们可以将它转化成以下两个不等式：

A - B >= c      (1)

A - B <= c      (2)

       再通过上面的方法将其中一种不等号反向，建图即可。

       最后，如果这些变量都是整数域上的，那么遇到A - B < c这样的不带等号的不等式，我们需要将它转化成"<="或者">="的形式，即 A - B <= c - 1。

四、差分约束的经典应用

      1、线性约束

        线性约束一般是在一维空间中给出一些变量（一般定义位置），然后告诉你某两个变量的约束关系，求两个变量a和b的差值的最大值或最小值。

      【例题1】N个人编号为1-N，并且按照编号顺序排成一条直线，任何两个人的位置不重合，然后给定一些约束条件。

       X(X <= 100000)组约束Ax Bx Cx(1 <= Ax < Bx <= N)，表示Ax和Bx的距离不能大于Cx。

       Y(X <= 100000)组约束Ay By Cy(1 <= Ay < By <= N)，表示Ay和By的距离不能小于Cy。

       如果这样的排列存在，输出1-N这两个人的最长可能距离，如果不存在，输出-1，如果无限长输出-2。

      像这类问题，N个人的位置在一条直线上呈线性排列，某两个人的位置满足某些约束条件，最后要求第一个人和最后一个人的最长可能距离，这种是最直白的差分约束问题，因为可以用距离作为变量列出不等式组，然后再转化成图求最短路。

      令第x个人的位置为d[x]（不妨设d[x]为x的递增函数，即随着x的增大，d[x]的位置朝着x正方向延伸）。

      那么我们可以列出一些约束条件如下：

      1、对于所有的Ax Bx Cx，有 d[Bx] - d[Ax] <= Cx；

      2、对于所有的Ay By Cy，有 d[By] - d[Ay] >= Cy；

      3、然后根据我们的设定，有 d[x] >= d[x-1] + 1 (1 < x <= N)  （这个条件是表示任何两个人的位置不重合）

      而我们需要求的是d[N] - d[1]的最大值，即表示成d[N] - d[1] <= T，要求的就是这个T。

     于是我们将所有的不等式都转化成d[x] - d[y] <= z的形式，如下：

      1、d[Bx]  -  d[Ax]    <=    Cx

      2、d[Ay]  -  d[By]    <=  -Cy

      3、d[x-1] -    d[x]    <=    -1

     对于d[x] - d[y] <= z，令z = w(y, x)，那么有 d[x] <= d[y] + w(y, x)，所以当d[x] > d[y] + w(y, x)，我们需要更新d[x]的值，这对应了最短路的松弛操作，于是问题转化成了求1到N的最短路。

        对于所有满足d[x] - d[y] <= z的不等式，从y向x建立一条权值为z的有向边。

      然后从起点1出发，利用SPFA求到各个点的最短路，如果1到N不可达，说明最短路(即上文中的T)无限长，输出-2。如果某个点进入队列大于等于N次，则必定存在一条负环，即没有最短路，输出-1。否则T就等于1到N的最短路。

#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
using namespace std;

const int maxn = 40000+10;
const int INF = 1e9+10;

struct node
{
    int from, to, cost;
    node(int from, int to, int cost) : from(from), to(to), cost(cost){}
};

vector<node> edge;
int d[1000 + 5];
int n,ml,md;

bool Bellman()
{
    for(int i = 1; i <= n; i++) d[i] = INF;
    d[1] = 0;
    int E = edge.size();
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < E; j++) {
            node e = edge[j];
            if (d[e.to] > d[e.from] + e.w) {
                d[e.to] = d[e.from] + e.w;
                if (i == n) return false; //如果存在负边，返回false
            }
        }
    }
    return true;
}

int main()
{
    scanf("%d%d%d",&n,&ml,&md);
    
    for(int i = 0; i < ml; i++){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        edge.push_back(node(u,v,w));
    }
    
    for(int i = 0; i < md; i++){
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        edge.push_back(node(v,u,-w));
    }
    
    if (!Bellman()) printf("-1\n");
    else if(d[n] == INF) printf("-2\n");
    else printf("%d\n",d[n]);
}