POJ 3169 (差分约束+SPFA)

题目：

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。按照编号顺序排成一排。在他们之间有些牛关系比较好，所以希望彼此之间不超过一定距离，给出ML表示有ML对（A,B,D），表示A与B间距离最大是D。也有一些牛关系非常不好，它们之间的距离也必须要大于一定距离。给出DL表示有DL对（A,B,D），表示A与B间距离最小是D。此外可能有多头牛站在同一个位置。求1号牛到N号牛之间的距离。如果不存在任何一种满足条件的排列方式则输出-1。无限大的情况输出-2。

题目分析：

首先题目中的隐含条件是

d[i] <= d[i + 1] 

即d[i + 1] + 0 >= d[i]

对于ML对时，d[j]-d[i]<=W[i,j];(j>i);    可转化为：d[j]<=d[i]+w[i,j];

对于MD对时，d[j]-d[i]>=W[i,j];(j>i);    可转化为：d[i]<=d[j]-w[i,j]=d[j]+w[j,i]；

 

然后呢就可以加边了，按最短路形式d[u]-d[v]<=w[v,u]建图,所有值都达到最大。

对于一个不等式 d[u] + w >= d[v] 我们可以加边(u, v , w),w是边的权值

这是由于在一个图里，从s出发，到各个顶点的v最短距离为d[v]，那么对一个边(u, v, w) 必然有d[u] + w >= d[v] 

注意：存在负环是无解的。

 

附上代码：

#include<iostream>//差分约束 
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<vector>
#define ll long long
#define Max 99999999
using namespace std;
int n,ml,md,cnt;
int head[1005],st[1005],dis[1005];
struct node{
	int id;
	int d;
	int next;
}g[20005];
void init()
{
	int i,j;
	for(i=0;i<=n;i++){
		head[i]=-1,st[i]=0;
		dis[i]=Max;
	}
	cnt=0;
}
void add(int x,int y,int xy)
{
	g[cnt].id =y;
	g[cnt].d =xy;
	g[cnt].next =head[x];
	head[x]=cnt++;
}
bool SPFA()
{
	int i,j,k;
	dis[1]=0;
	int mp[1005]={0};
	mp[1]=1;
	st[1]++;
	queue<node> p;
	node q;
	q.d =0;
	q.id =1;
	p.push(q);
	while(p.size())
	{
	    q=p.front() ;
		p.pop() ;
		mp[q.id ]=0;
		for(i=head[q.id ];i!=-1;i=g[i].next )
		{
			if(dis[g[i].id ]>dis[q.id ] +g[i].d ){
				dis[g[i].id ]=dis[q.id ]+g[i].d ;
				p.push(g[i]);st[g[i].id ]++; 
				mp[g[i].id ]=1;
			}
			if(st[g[i].id ]>=n)return false;//判断有无负环，若一个点访问的次数不低于n次，则说明存在负环，因为此时
			//没有最短路，越走负环，最短距离越短 
		}
	} 
	return true;
}
int main()
{
	while(scanf("%d%d%d",&n,&ml,&md)!=EOF)
	{
		int i,j,k;
		init();
		while(ml--)
		{
			scanf("%d%d%d",&i,&j,&k);
			if(i>j)swap(i,j);
			add(i,j,k);//小指向大 
		}
		while(md--)
		{
			scanf("%d%d%d",&i,&j,&k);
			if(i<j)swap(i,j);
			k=k*(-1);
			add(i,j,k);//大指向小，k为负值 
		}
		if(SPFA())
		{
			if(dis[n]==Max)//好好理解，不存在负环，但1到n之间不存在通路，所以距离越大越好 
			{
				printf("-2\n");
			}
			else printf("%d\n",dis[n]);
		}
		else {//存在负环，无最短路 
			printf("-1\n");
		}
	}
    return 0;
}