#include <bits/stdc++.h>

using namespace std;

ifstream f("distante.in");
ofstream g("distante.out");

const int NMAX=5e4+5;

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

priority_queue < pair <int, int>, vector < pair <int, int> >, greater < pair <int, int> > > H;

int T, N, M, S, t, D[NMAX], SOL[NMAX], i, j;

//D[i] - distanta data pentru nodul i;
//SOL[i] - distanta calculata pentru nodul i;

int a, b, c, nod, cnt;

bool Sel[NMAX];

int main()
{
    f>>T;

    for(t=1; t<=T; ++t)
    {
        f>>N>>M>>S;

        for(i=1; i<=N; ++i)
            f>>D[i];

        for(i=1; i<=M; ++i)
        {
            f>>a>>b>>c;

            G[a].push_back({b, c});
            G[b].push_back({a, c});
        }

        for(i=1; i<=N; ++i)
            SOL[i]=-1;

        SOL[S]=0;
        Sel[S]=true;

        for(i=0; i<G[S].size(); ++i)
        {
            SOL[G[S][i].first]=G[S][i].second;

            H.push({G[S][i].second, G[S][i].first});
        }

        cnt=G[S].size();

        //Dijkstra:
        while(cnt!=0)
        {
            while(Sel[H.top().second]==true)
                H.pop();

            nod=H.top().second;
            Sel[nod]=true;

            H.pop();
            cnt--;

            for(i=0; i<G[nod].size(); ++i)
            {
                j=G[nod][i].first; //Nod

                if(SOL[j]==-1)
                {
                    cnt++;

                    SOL[j]=SOL[nod]+G[nod][i].second;

                    H.push({SOL[j], j});
                }
                else
                {
                    if(SOL[nod]+G[nod][i].second < SOL[j])
                    {
                        SOL[j]=SOL[nod]+G[nod][i].second;

                        H.push({SOL[j], j});
                    }
                }
            }
        }

        bool ok=true;

        for(i=1; i<=N; ++i)
            if(D[i]!=SOL[i])
            {
                ok=false;

                break;
            }

        if(ok==true)
            g<<"DA"<<'\n';
        else
            g<<"NU"<<'\n';

        for(i=1; i<=N; i++)
        {
            Sel[i]=false;

            if(G[i].size())
                G[i].clear();
        }

        while(!H.empty())
            H.pop();

    }

    return 0;
}