#include <iostream>
#include <fstream>
#include <vector>
#include <utility>
#include <queue>
#include <algorithm>
#include <climits>
#include <cstring>
#include <unordered_map>


using namespace std;

ifstream fin ("distante.in");
ofstream fout ("distante.out");

vector < vector < pair <int,int> > > edge;
vector <int> distanceBF, distanceIN;
vector <int> used;
int N, M, T, source;


void Bellman_Ford (int node)
{
    queue <int> NodeQ;

    NodeQ.push(node);

    used[node] = 1;
    distanceBF[node] = 0;

    while (!NodeQ.empty())
	{
        node = NodeQ.front();
        NodeQ.pop();
        used[node] = 0;
        for (int i = 0; i < edge[node].size(); ++i)
			if (distanceBF[node] < INT_MAX)
			{
				int _node = edge[node][i].first;
				int cost = edge[node][i].second;
				if (distanceBF[_node] > distanceBF[node] + cost)
				{
					distanceBF[_node] = distanceBF[node] + cost;
					if (!used[_node])
					{
						used[_node] = 1;
						NodeQ.push(_node);
					}
				}
			}
	}
}

void initialize()
{
	edge.clear();
	distanceBF.clear();
	distanceIN.clear();
	used.clear();
	edge.resize(N+1);
	distanceBF.resize(N+1);
	distanceIN.resize(N+1);
	used.resize(N+1);
	fill(distanceBF.begin(), distanceBF.begin()+N+1,INT_MAX);
	fill(distanceIN.begin(), distanceIN.begin()+N+1,INT_MAX);
}

int main()
{
    fin >>T;

    for (int i = 1; i <= T; ++i)
	{
        fin >>N >>M >>source;

        initialize();

        for (int i = 1; i <= N; ++i)
			fin >>distanceIN[i];

		for (int i = 1; i <= M; ++i)
		{
            int x, y, c;
            fin >>x >>y >>c;
            edge[x].push_back(make_pair(y,c));
            edge[y].push_back(make_pair(x,c));
		}

		Bellman_Ford(source);

		int j = 0;
		while(distanceIN[j] == distanceBF[j] && j <= N)
			++j;
		if (j == N)
			fout <<"DA" <<'\n';
		else
			fout <<"NU" <<'\n';
	}
}