#include <fstream>
#include <vector>
#define TMAx 10
#define NMAx 50100
#define oo (1<<30)
#define Vecin first
#define Cost second
using namespace std;

vector < pair<int,int> > G[TMAx][NMAx];
int T,N,M,S,Sol,V[NMAx];
string Answer[2]={"NU","DA"};

///////////////////////
#define MaxBuffer 8192
char buffer[MaxBuffer];
int bufferIndex=8191;
///////////////////////

inline void read_buffer(istream& in,int& x) {
	do {if(++bufferIndex==MaxBuffer) {
		bufferIndex=0;
		in.read(buffer,MaxBuffer);
		}
	}while( buffer[bufferIndex]<'0'||buffer[bufferIndex]>'9' );
 
	for(x=0;buffer[bufferIndex]>='0'&&buffer[bufferIndex]<= '9';) {
		x=x*10+buffer[bufferIndex]-'0';
		if(++bufferIndex==MaxBuffer) {
			bufferIndex=0;
			in.read(buffer,MaxBuffer);
			}
		}
}
class HEAP {
	
	#define left(i) (2*i)
	#define right(i) (2*i+1)
	#define father(i) (i/2)
	#define cmp(X,Y) (Dist[A[X]]<=Dist[A[Y]])
	
	private:
		int Vf,A[NMAx],Loc[NMAx];
	public:
		int Dist[NMAx];
	public:
		void Init(int N,int Val);
		int size();
		int root();
		void Update(int Nod,int Val);
		void pop();
		void Up(int Nod);
		void Down(int Nod);
		
}Heap;
int HEAP::size() {
	return Vf;
}
void HEAP::Init(int N,int Val) {
	
	Vf=N;
	for(int i=1;i<=N;i++) {
		Dist[i]=Val;
		A[i]=i;
		Loc[i]=i;
		}
		
}
int HEAP::root() {
	return A[1];
}
void HEAP::Update(int Nod,int Val) {
	
	Dist[Nod]=Val;
	Up(Loc[Nod]);
	
}
void HEAP::pop() {
	
	A[1]=A[Vf--];
	Loc[A[1]]=1;
	Down(1);
	
}
void HEAP::Up(int Nod) {
	
	while(Nod>1&&cmp(Nod,father(Nod))) {
		swap(A[Nod],A[father(Nod)]);
		swap(Loc[A[Nod]],Loc[A[father(Nod)]]);
		Nod=father(Nod);
		}
	
}
void HEAP::Down(int Nod) {
	
	int Fiu;
	do {
		Fiu=0;
		if(left(Nod)<=Vf) {
			Fiu=left(Nod);
			if(right(Nod)&&cmp(right(Nod),Fiu))
				Fiu=right(Nod);
			if(cmp(Nod,Fiu))
				Fiu=0;
			}
		
		if(Fiu) {
			swap(A[Nod],A[Fiu]);
			swap(Loc[A[Nod]],Loc[A[Fiu]]);
			Nod=Fiu;
			}
	}while(Fiu);
	
}

bool Verif() {
	
	for(int i=1;i<=N;i++)
		if(Heap.Dist[i]!=V[i])
			return 0;
			
	return 1;
	
}
void Solve() {
	
	int i,Nod;
	
	Heap.Update(S,0);
	
	while(Heap.size()) {
		
		Nod=Heap.root();
		Heap.pop();
		
		for(i=0;i<G[T][Nod].size();i++)
			if(Heap.Dist[G[T][Nod][i].Vecin]>Heap.Dist[Nod]+G[T][Nod][i].Cost)
				Heap.Update(G[T][Nod][i].Vecin,Heap.Dist[Nod]+G[T][Nod][i].Cost);
		
		}
	
}
void Citire(ifstream & in) {
	
	int i,X,Y,C;
	
	read_buffer(in,N);
	read_buffer(in,M);
	read_buffer(in,S);
	for(i=1;i<=N;read_buffer(in,V[i++]));
	for(i=1;i<=M;i++) {
		read_buffer(in,X);
		read_buffer(in,Y);
		read_buffer(in,C);
		G[T][X].push_back(make_pair(Y,C));
		G[T][Y].push_back(make_pair(X,C));
		}
	
}
int main() {
	
	ifstream in("distante.in");
	ofstream out("distante.out");
	
	in>>T;
	
	while(T) {
		
		T--;
		Citire(in);
		
		if(!V[S]) {
			Heap.Init(N,oo);
			Solve();
			Sol=Verif();
			}
		else
			Sol=0;
		
		out<<Answer[Sol]<<'\n';
		
		}
	
	in.close();
	out.close();
	
	return 0;
	
}