#include <iostream>
#include <vector>
#include <queue>
#include <utility>
#include <stdio.h>
#include <cassert>
#include <string.h>

#define INF 100000
using namespace std;

int N, M;

void Solve(std::vector <std::vector <std::pair <int, int> > > &G, int * Parent, int s, int dist[]) {

    std::priority_queue< std::pair<int, int>,
   	std::vector<std::pair<int, int> >, 
   	std::greater<std::pair<int, int> > > q;
  	
  	bool selectat[N];
  	
  	// initializare
  	for (int i = 1; i <= N; i++) {
  		selectat[i] = false;
  		dist[i] = INF;
  		Parent[i] = -1;
  	}
  	
  	dist[s] = 0;  
    selectat[s] = true;
    
    for (unsigned int i = 0; i < G[s].size(); i++) {
    
    	int v = G[s][i].first;
    	
    	dist[v] = G[s][i].second;
    	q.push(std::make_pair(G[s][i].second, v));
    	Parent[v] = s;
    }
    
    while (!q.empty()) {
    	
    	int u = (q.top()).second;
    	int cost = (q.top()).first;
    	q.pop();
    	
    	if (cost != dist[u]) continue;
    	
    	selectat[u] = true;
    	
    	for (unsigned int i = 0; i < G[u].size(); i++) {
    		
    		if (selectat[G[u][i].first] == false && dist[G[u][i].first] > (dist[u] + G[u][i].second)) {
  
    			dist[G[u][i].first] = dist[u] + G[u][i].second;
    			Parent[G[u][i].first] = u;
    				
    			q.push(std::make_pair(dist[G[u][i].first], G[u][i].first)); // actualizez costul nou
    		}
    	}	
    }
}


int main() {
	
	int x, y, c, nr, source;
	
	FILE* fin = fopen("distante.in", "r");
	FILE* fout = fopen("distante.out", "w"); 
	
	fscanf(fin, "%d", &nr);
	
	for (int i = 0; i < nr; i++) {
	
		assert(fscanf(fin, "%d %d %d", &N, &M, &source) == 3);
		
		int sol[N + 1]; // solutia primita
		std::vector<std::vector<std::pair<int, int> > > G(N + 1); // graful
		int dist[N + 1]; // solutaia calculata
		bool not_ok = false;
		
		for (int i = 1; i <= N; i++) {
			fscanf(fin, "%d", &sol[i]);
		}
	
		// pentru un graf orientaaaaat!!!!
		for (int i = 0; i < M; i++) {
			assert(fscanf(fin, "%d %d %d", &x, &y, &c) == 3);
			G[x].push_back(std::make_pair(y, c));
			G[y].push_back(std::make_pair(x, c));
		}
	
		int Parent[1000000];
		memset(Parent, 0, sizeof(int) * (N + 1));
		
		Solve(G, Parent, source, dist);
		
		for (int i = 1; i <= N; i++) {
			if (dist[i] == INF) {
				dist[i] = 0;
			}
			
			if (dist[i] != sol[i]) {
				not_ok = true;
				break;
			}
		}
		
		if (!not_ok) {
			fprintf(fout, "DA\n");
		}
		else {
			fprintf(fout, "NU\n");
		}
	}
	
	fclose(fin);
	fclose(fout);
}