#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

        if(!vizDij[nod_curent])
        {
            vizDij[nod_curent] = 1;
            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;
                    q.push({dist[y],y});                                // adaugam din nou in coada pt ce ne ar putea imbunatati costul ulterior
                }
            }
        }

    }

    for(int i = 1; i <= N; ++i)
        if(dist[i] == inf)
            dist[i] = 0;

    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.resize(N+1);
        Sol = Dijkstra(S);

        // afisare
        bool test = 1;

        if(D.size() != Sol.size())
            test = 0;

        if(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;
}