【poj3169】Layout 差分约束

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.

Source

USACO 2005 December Gold

---

题意就是说，有一群奶牛排成一列，给出两个奶牛之间距离之间的关系：分别为a-b>=c和a-b<=c，还要求相邻两个距离大于等于0（能重合，好可怕）。现在求一号和n号之间最远距离。若可以任意远则输出-2，若不能排成一列则输出-1。

---

差分约束裸题……

因为是在一个数轴上，要注意位置之间的关系。所以我们定义右边为正方向，对于每组关系，定义 右边的-左边的 为它们的距离。并且总是让序号大的站右边。这样给出的关系就好处理了。

差分约束无解的条件是有负环，所以有负环输出-1。任意远则可以认为它们之间没有间接关系，若走不到终点则输出-2。

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue> 
using namespace std;
const int INF=2000000000;
const int SIZE=100010;

int head[SIZE],nxt[SIZE],dist[SIZE];

struct edge{
    int t,d;
}l[SIZE];

int tot=0;
void build(int f,int t,int d)
{
    l[++tot].t=t;
    l[tot].d=d;
    nxt[tot]=head[f];
    head[f]=tot;
}

int n;

bool use[SIZE];
deque<int> q;
int t[SIZE];
int spfa(int s)
{
    for(int i=1;i<=n;i++) dist[i]=INF;
    dist[s]=0;
    use[s]=1;
    q.push_front(s);
    while(q.size())
    {
        int f=q.front(); q.pop_front();
        use[f]=0;
        for(int i=head[f];i;i=nxt[i])
        {
            int v=l[i].t;
            if(dist[v]>dist[f]+l[i].d)
            {
                dist[v]=dist[f]+l[i].d;
                if(!use[v])
                {
                    if(++t[v]>n) return -1;
                    if(q.empty()) q.push_front(v);
                    else
                    {
                        if(dist[q.front()]>dist[v])
                            q.push_front(v);
                        else
                            q.push_back(v);
                    }
                }
            }
        }
    }
    if(dist[n]==INF) return -2;
    return dist[n];
}

int main()
{
    int m1,m2;
    scanf("%d%d%d",&n,&m1,&m2);
    for(int i=1;i<=m1;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        if(a>b) swap(a,b);
        build(a,b,c);
    }
    for(int i=1;i<=m2;i++)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        if(a<b) swap(a,b);
        build(a,b,-c);
    }   
    for(int i=1;i<n;i++)
    {
        build(i+1,i,0);
    }
    printf("%d",spfa(1));
    return 0;
}