虫洞能够时光倒流，判断能否在回到出发的位置的时候在出发的时候之前。（判断是否存在负环）

初学最短路，尝试着用了三种方法判断：

1、Bellman Ford （令d全部为0，仅用来判断负环）       OJ测试得157MS

2、Bellman Ford 结束后再来一轮松弛若松弛成功则存在负环。    235MS

3、Bellman Ford 用队列优化过的SPFA，判断是否存在一个点同队大于等于N次，若存在则表示存在负环。（WA！原因还没弄清楚，先留着，好像效率不太好，一般不用这种方式判断负环）

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int F, N, M, W;
const int MAXN = 501, MAXM = 5201, INF = 0x3f3f3f3f;
struct Edge
{
	int u, v, w;
}e[MAXM];
int d[MAXN];
int Bellman_Ford()
{
	memset(d, 0x3f, sizeof(d));
	d[1] = 0;
	for(int k = 0; k < N-1; k++)
		for(int i = 0; i < 2*M+W; i++)
		{
			int u = e[i].u, v = e[i].v, w = e[i].w;
			if(d[u] < INF)
				d[v] = min(d[v], d[u] + w);
		}
	//判断负环		
	for(int i = 0; i < 2*M+W; i++)
	{
		int u = e[i].u, v = e[i].v, w = e[i].w;
		if(d[v] > d[u] + w)
			return 1;
	}
	return 0;
}
//d=0判断负环
bool find_negative_loop()
{
	memset(d, 0, sizeof(d));
	for(int i = 0; i < N; i++)
		for(int j = 0; j < 2*M+W; j++)
		{
			int u = e[j].u, v = e[j].v, w = e[j].w;
			if(d[v] > d[u] + w)
			{
				d[v] = d[u] + w;
				if(i == N-1) return true;
			}
		}
	return false;
}

#include <queue>
int first[MAXN], nexte[MAXM], times[MAXN];
bool inq[MAXN];
int SPFA()
{
	queue<int> q;
	memset(times, 0, sizeof(times));
	memset(d, 0x3f, sizeof(d));
	d[1] = 0;
	memset(inq, 0, sizeof(inq));
	q.push(0);
	while(q.size())
	{
		int u = q.front(); q.pop();
		inq[u] = false;					//清除标志
		for(int i = first[u]; i != -1; i = nexte[i])	//M条边
		{
			int u = e[i].u, v = e[i].v, w = e[i].w;
			if(d[v] > d[u] + w)
			{

				d[v] = d[u] + w;
				if(!inq[v])
				{
					times[v]++;
					if(times[v] >= N)
						return 1;

					inq[v] = true;
					q.push(v);
				}
			}
		}
	}
	return 0;
}

int main()
{
	//freopen("in.txt", "r", stdin);
	scanf("%d", &F);
	while(F--)
	{
		scanf("%d%d%d", &N, &M, &W);
		for(int i = 1; i <= N; i++) first[i] = -1;
		for(int i = 0; i < 2*M; i+=2)
		{
			scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
			e[i+1].u = e[i].v, e[i+1].v = e[i].u, e[i+1].w = e[i].w;
			nexte[i] = first[e[i].u];
			first[e[i].u] = i;
			nexte[i+1] = first[e[i+1].u];
			first[e[i+1].u] = i;
		}
		for(int i = 2*M; i < 2*M+W; i++)
		{
			scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
			e[i].w *= -1;
			nexte[i] = first[e[i].u];
			first[e[i].u] = i;
		}

		printf(find_negative_loop() ? "YES\n" : "NO\n");
		//printf(Bellman_Ford() ? "YES\n" : "NO\n");
		//printf(SPFA() ? "YES\n" : "NO\n");
	}
	return 0;
}