#include <fstream>
#include <queue>
#include <iostream>
#define inf 0x3f3f3f3f
using namespace std;

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

const int nmax = 50005;

int t;

int n, m, s;
int bronzDist[nmax];
int actualDist[nmax];

vector < pair < int, int > > G[nmax];
vector < bool > seen;
vector < bool > inQueue;

struct comparaDistante
{
    bool operator() (int x, int y)
    {
        return actualDist[x] > actualDist[y];
    }
};

priority_queue < int , vector < int > , comparaDistante > coada;

void Dijkstra(int startNode)
{
    for(int i = 1; i <= n; ++i)
    {
        actualDist[i] = inf;
    }

    actualDist[startNode] = 0;
    coada.push(startNode);
    inQueue[startNode] = 1;

    while(!coada.empty())
    {
        int nodCurent = coada.top();
        coada.pop();
        inQueue[nodCurent] = 0;

        for(size_t i = 0; i < G[nodCurent].size(); ++i)
        {
            int vecin = G[nodCurent][i].first;
            int cost = G[nodCurent][i].second;

            if(actualDist[nodCurent] + cost < actualDist[vecin])
            {
                actualDist[vecin] = actualDist[nodCurent] + cost;

                if(!inQueue[vecin])
                {
                    inQueue[vecin] = 1;
                    coada.push(vecin);
                }
            }
        }
    }

}

int main()
{
    fin >> t;
    while(t--)
    {
        fin >> n >> m >> s;

        seen = vector < bool > (n + 1, 0);
        inQueue = vector < bool > (n + 1, 0);

        for(int i = 1; i <= n; ++i)
        {
            fin >> bronzDist[i];
        }
        for(int i = 1; i <= m; ++i)
        {
            int x, y, c;
            fin >> x >> y >> c;
            G[x].push_back({y, c});
            G[y].push_back({x, c});
        }

        Dijkstra(s);


        bool keepGoing = true;

        for(int i = 1; i <= n && keepGoing; ++i)
        {
            if(actualDist[i] != bronzDist[i])
            {
                fout << "NU\n";
                keepGoing = false;
            }
        }

        if(keepGoing) fout << "DA\n";

        for(int i = 1; i <= n; ++i)
            G[i].clear();
    }
    return 0;
}