[USACO05DEC] 布局

题意翻译
正如其他物种一样，奶牛们也喜欢在排队打饭时与它们的朋友挨在一起。FJ 有编号为 1\dots N1…N 的 NN 头奶牛 (2\le N\le 1000)(2≤N≤1000)。开始时，奶牛们按照编号顺序来排队。奶牛们很笨拙，因此可能有多头奶牛在同一位置上。

有些奶牛是好基友，它们希望彼此之间的距离小于等于某个数。有些奶牛是情敌，它们希望彼此之间的距离大于等于某个数。

给出 M_LM
L
​ 对好基友的编号，以及它们希望彼此之间的距离小于等于多少；又给出 M_DM
D
​ 对情敌的编号，以及它们希望彼此之间的距离大于等于多少 (1\le M_L,(1≤M
L
​ , M_D\le 10^4)M
D
​ ≤10
4
)。

请计算：如果满足上述所有条件，11 号奶牛和 NN 号奶牛之间的距离最大为多少。

输入输出格式
输入格式
第一行：三个整数 N, M_L, M_DN,M
L
​ ,M
D
​ ，用空格分隔。

第 2\dots M_L+12…M
L
​ +1 行：每行三个整数 A, B, DA,B,D，用空格分隔，表示 AA 号奶牛与 BB 号奶牛之间的距离须 \le D≤D。保证 1\le A<B\le N,1≤A<B≤N, 1\le D\le 10^61≤D≤10
6
.

第 M_L+2\dots M_L+M_D+1M
L
​ +2…M
L
​ +M
D
​ +1 行：每行三个整数 A, B, DA,B,D，用空格分隔，表示 AA 号奶牛与 BB 号奶牛之间的距离须 \ge D≥D。保证 1\le A<B\le N,1≤A<B≤N, 1\le D\le 10^61≤D≤10
6
.

输出格式
一行，一个整数。如果没有合法方案，输出 -1. 如果有合法方案，但 11 号奶牛可以与 NN 号奶牛相距无穷远，输出 -2. 否则，输出 11 号奶牛与 NN 号奶牛间的最大距离。

题目背景
13组数据，前10组为原数据，后3组为hack数据

题目描述
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.

输入输出格式
输入格式：
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.

输出格式：
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.

输入输出样例
输入样例#1：
4 2 1
1 3 10
2 4 20
2 3 3
输出样例#1：
27
说明
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.

.
.
.
.
.
.
.
分析
显然是差分约束。
但是我们只是spfa(1) 是不够的，这样只能满足1 到n的结果，而队于从1 出发无法到达的点却不能保证是否有解。
因此虚拟一个节点0，同时0连向所有的点，spfa(0) 来判断负环（即无解的情况），spfa(1) 来求距离的最值。

.
.
.
.
.
程序：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;


struct edge
{
	int to,from,v;
}e[800010];

int dis[400010],head[400010],cnt=1,bz[400010],inf=0X7f7f7f7f,n;
bool f[400010];

inline int read(){
   int s=0,w=1;
   char ch=getchar();
   while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
   while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
   return s*w;
}


void insert(int x,int y,int v)
{
	e[++cnt].to=y;e[cnt].from=head[x];e[cnt].v=v;head[x]=cnt;
}

bool spfa(int x)
{
	queue<int>q;
	memset(dis,inf,sizeof(dis));
	memset(bz,0,sizeof(bz));
	memset(f,false,sizeof(f));
    f[x]=true;
    dis[x]=0;
	q.push(x);
    while (!q.empty())
    {
        int u=q.front();
		q.pop();
		f[u]=false;
		if (bz[u]==n) return false;
		bz[u]++;
        for (int i=head[u];i!=-1;i=e[i].from)
            if (dis[e[i].to]>dis[u]+e[i].v)
            {
                dis[e[i].to]=dis[u]+e[i].v;
                if (!f[e[i].to])
                {
                    f[e[i].to]=true;
                    q.push(e[i].to);
                }
            }
    }
    return true;
}

int main()
{
	int ml,md;
	n=read();ml=read();md=read();
	memset(head,-1,sizeof(head));
	for (int i=1;i<=ml;i++)
	{
		int a,b,d;
		a=read();b=read();d=read();
		insert(a,b,d);
	}
	for (int i=1;i<=md;i++)
	{
		int a,b,d;
		a=read();b=read();d=read();
		insert(b,a,-d);
	}
	for (int i=1;i<=n;i++)
		insert(0,i,0);
	if (!spfa(0))
	{
		printf("-1");
		return 0;
	}
	spfa(1);
	if (dis[n]<inf) printf("%lld",dis[n]); else printf("-2");
	return 0;
}