#include <bits/stdc++.h>
#define NMax 50001
#define inf INT_MAX

using namespace std;

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


int T;                                  // nr de grafuri
int N, M, S;                            // noduri, muchii, nod sursa
vector<pair<int,int>> muchii[NMax];     // struct de date pt muchii



vector<int> Dijkstra(int s)
{
    priority_queue <pair<int,int>> q;   // coada cu prioritati {cost,nod}
    vector <bool> vizDij(N+1, 0);       // viz[x] = 1 daca nodul a fost vizitat
    vector <int> dist(N+1, inf);        // dist[x] = distanta de la nodul de start la nodul x   // initial presupunem fiecare distanta ca fiind infinit


    q.push({0,s});      // adaugam in coada nodul de inceput cu costul 0 (de la s la s avem distanta 0)
    vizDij[s] = 1;      // marcam nodul ca fiind vizitat
    dist[s] = 0;        // distanta de la s la s va fi 0

    while(!q.empty())
    {
        int nod_curent = q.top().second;        // nodul curent
        q.pop();

        vizDij[nod_curent] = 0;                 // presupunem ca nodul curent nu a fost vizitat inca

        for(int i = 0 ; i < (int)muchii[nod_curent].size(); ++i)    // parcurgem nodurile adiacente cu nodul curent
        {
            int y = muchii[nod_curent][i].second;                   // nodul adiacent cu nodul curent
            int cost = muchii[nod_curent][i].first;                 // costul de la nodul curent  pana la y

            if(dist[nod_curent] + cost < dist[y])
            {
                dist[y] = dist[nod_curent] + cost;
                if(!vizDij[y])                  // marcam nodul ca fiind vizitat daca nu era
                {
                    vizDij[y] = 1;
                    q.push({dist[y],y});        // adaugam din nou in coada pt ce ne ar putea imbunatati costul ulterior
                }
            }
        }
    }

    return dist;
}


void Read()
{
    fin >> T;

    for(int i = 1; i <= T; ++i)
    {
        fin >> N >> M >> S;                         // citire nr noduri, nr muchii, nod sursa


        vector <int> D;                             // distantele minime calculate de Bronzarel
        D.resize(N+1);
        for(int j = 1; j <= N; ++j) fin >> D[j];    // citire distante calculate de Bronzarel


        for(int j = 1; j <= N; ++j)
            muchii[j].erase(muchii[j].begin(), muchii[j].end());
        for(int j = 1; j <= M; ++j)                 // citire graf neorientat ponderat
        {
            int x, y, cost;
            fin >> x >> y >> cost;
            muchii[x].push_back({cost,y});
            muchii[y].push_back({cost,x});
        }


        vector <int> Sol;
        Sol = Dijkstra(S);

        bool test = 1;
        for(int j = 1; j <= N; ++j)
            if(D[j] != Sol[j])
            {
                test = 0;
                break;
            }

        if(test == 1)
            fout << "DA\n";
        else
            fout << "NU\n";
    }
}


int main()
{
    Read();

    return 0;
}