#include <iostream>
#include <fstream>
#include <cstring>
#include <vector>
using namespace std;
ifstream fin("distante.in");
ofstream fout("distante.out");

const int NMax = 50005;
const int oo = 1 << 30;

int T,NHeap;
int N,M,S;
int D[NMax],F[NMax];
int Heap[NMax],Poz[NMax];
bool OK;

vector < pair <int,int> > G[NMax];

void Read()
{
    memset(D,0,sizeof(D));

    fin >> N >> M >> S;

    for(int i = 1 ; i <= N ; ++i)
    {
        fin >> D[i];
        G[i].clear();
    }

    for(int i = 1 ; i <= M ; ++i)
    {
        int a,b,c;  fin >> a >> b >> c;
        G[a].push_back(make_pair(b,c));
        G[b].push_back(make_pair(a,c));
    }
}

void UpHeap(int Nod)
{
    int Tata = Nod >> 1;

    if(Tata > 0 && F[Heap[Tata]] > F[Heap[Nod]])
    {
        swap(Heap[Tata] , Heap[Nod]);
        swap(Poz[Heap[Tata]] , Poz[Heap[Nod]]);
        UpHeap(Tata);
    }
}

void DownHeap(int Nod)
{
    int Fiu = Nod << 1;

    if(Fiu + 1 <= NHeap && F[Heap[Fiu]] > F[Heap[Fiu + 1]])
        Fiu++;

    if(Fiu <= NHeap && F[Heap[Nod]] > F[Heap[Fiu]])
    {
        swap(Heap[Fiu] , Heap[Nod]);
        swap(Poz[Heap[Fiu]] , Poz[Heap[Nod]]);
        DownHeap(Fiu);
    }
}

void Solve()
{
    OK = 1;

    for(int i = 1 ; i <= N ; ++i)
    {
        F[i] = oo;
        Heap[i] = i;
        Poz[i] = i;
    }

    F[S] = 0;
    UpHeap(S);
    NHeap = N;

    for(int k = 1 ; k <= N ; ++k)
    {
        int Nod = Heap[1];

        if(D[Nod] != F[Nod])
        {
            OK = 0;
            return;
        }

        swap(Poz[Heap[1]] , Poz[Heap[NHeap]]);
        Heap[1] = Heap[NHeap];
        NHeap--;
        DownHeap(1);

        for(int i = 0 ; i < (int) G[Nod].size() ; ++i)
        {
            int Vecin = G[Nod][i].first;
            int Cost = G[Nod][i].second;

            if(F[Vecin] > F[Nod] + Cost)
            {
                F[Vecin] = F[Nod] + Cost;
                UpHeap(Vecin);
            }
        }
    }
}

void Print()
{
    if(OK)  fout << "DA\n";
    else    fout << "NU\n";
}

int main()
{
    fin >> T;

    while(T--)
    {
        Read();
        Solve();
        Print();
    }

    fin.close();
    fout.close();
    return 0;
}