#include <bits/stdc++.h>
#define NMax 50005
#define inf 2e9

using namespace std;

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


int T;              // nr de grafuri
int N, M, S;        // noduri, muchii, nod sursa
int D[NMax];        // distantele minime calculate


bool Dijkstra(int s, vector<pair<int,int>> muchii[2*NMax])
{
    priority_queue <pair<int,int>> q;   // coada cu prioritati {cost,nod}
    bool vizDij[NMax] = {0};            // viz[x] = 1 daca nodul a fost vizitat
    int dist[NMax];                     // dist[x] = distanta de la nodul de start la nodul x
    vector <int> Sol;

    // initial presupunem fiecare distanta ca fiind infinit
    for(int i = 1; i <= N; ++i)
        dist[i] = inf;

    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(auto i : muchii[nod_curent])        // parcurgem nodurile adiacente cu nodul curent
        {
            int y = i.second;                   // nodul adiacent cu nodul curent
            int cost = 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
                }
            }
        }
    }

    //fout << dist[S];
    for(int i = 1; i <= N; ++i)
        if(D[i] != dist[i])
            return 0;

    return 1;
}


void Restabilire()
{
    for(int i = 1; i <= N; ++i)
        D[i] = 0;
}


void Read()
{
    fin >> T;

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

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

        vector<pair<int,int>> muchii[2*NMax];   // citire grafuri neorientate ponderate
        for(int j = 1; j <= M; ++j)
        {
            int x, y, cost;
            fin >> x >> y >> cost;
            muchii[x].push_back({cost,y});
        }

        if(Dijkstra(S, muchii))                 // verificare daca distantele au fost calculate corect
            fout << "DA\n";
        else
            fout << "NU\n";

        Restabilire();                          // punem 0 in vect D pentru al putea refolosi pt urmatorul graf citit
    }
}


int main()
{
    Read();
    return 0;
}