hdu3169

                                                                                                       Layout

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 5492		Accepted: 2624

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.

 

 

 

#include<iostream>
#include<queue>
using namespace std;
const int N = 1005;          //有N头牛
const int INF = 0x3f3f3f3f;  //定义一个大数作为无穷大
int NUM;                     //前向星变量，记录边数
int head[N];                 //前向星表头
bool flag[N];                //标记是否在队列
int dis[N];                  //标记1到其他顶点的最短距离
int sum[N];                  //标记入队次用，用于判断负环

struct Node{                 //记录关系
    int v,w,next;            //目标点，权值，下一点索引
}node[20005];


void add(int a,int b,int c){ //前向星加边函数
    node[NUM].v = b;
    node[NUM].w = c;
    node[NUM].next = head[a];
    head[a] = NUM++;
}

int SPFA(int s,int n){
    int i;
    for(i=0;i<=n;i++){    
        sum[i] = 0;         //初始化所有点入队次数为0
        flag[i] = false;    //初始化队列标记，false为未入队
        dis[i] = INF;       //初始化1到其他顶点距离为无穷大
    }
    queue<int> q;           //定义一个队列，存放维护的点
    q.push(s);              //把源点放进队列
    dis[s]=0;               //到自身距离为0
    while(!q.empty()){      //若队列不为空
        int u = q.front();  //取队列头元素
        q.pop();            //取元素后，元素弹出
        flag[u] = false;    //标记为不在队列
        for(i=head[u];~i;i=node[i].next)
        { //遍历与U相连的所有点
            int v = node[i].v;            //终点 
            int w = node[i].w;            //起点到终点权值
            if(dis[v] > dis[u] + w)
            {      //
                dis[v] = dis[u] + w;
                if(!flag[v])
                {             //若不再队列
                    q.push(v);            //把点放进队列维护 
                    flag[v] = true;       //标记为在队列
                    if(++sum[v] > n)
                    {     //入队数++，如果超过n，存在负环
                        return -1;  
                    }
                }
            }
        }

    }
    if(dis[n] == INF) return -2;
    return dis[n];
}

int main(){
    int n,ml,md,a,b,c;
    while(scanf("%d%d%d",&n,&ml,&md)!=EOF){
        memset(head,255,sizeof(head));   //初始化表头
        NUM = 0;
        while(ml--){                     //喜欢
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);                  //b-a<=c
        }
        while(md--){                     //不喜欢
            scanf("%d%d%d",&a,&b,&c); 
            add(b,a,-c);                 //b-a>=c
        }
        printf("%d
",SPFA(1,n));
    }
    return 0;
}