#include <iostream>
#include <fstream>
#include <vector>
#include <climits>
#include <queue>
#include <set>

#define inf 999999

using namespace std;

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

int n, m, sursa, T;
bool visited[50001];
int value[50001];

vector<pair<int, int> > adj[50001];
void dijkstra(int start)
{
    priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > Q;
    Q.push(make_pair(0, start));
    while (Q.empty() == 0)
    {
        int nod_curent = Q.top().second;
        Q.pop();
        if (visited[nod_curent] == 0)
        {
            visited[nod_curent] = 1;
            for (int i = 0; i < int(adj[nod_curent].size()); i++)
            {
                int vecin = adj[nod_curent][i].first;
                if (value[vecin] > value[nod_curent] + adj[nod_curent][i].second)
                {
                    value[vecin] = value[nod_curent] + adj[nod_curent][i].second;
                    Q.push(make_pair(value[vecin], vecin));
                }
            }
        }
    }
}

void dijkstra1(int sursa)
{
    set<pair<int, int> > set_cost_nod; // set_cost_nod retine nodurile inca neprocesate si costul pt a ajunge in ele
    // folosim set pt ca atunci cand vom lua un alt nod vrem sa il luam pe cel cu costul minim
    //  ce se afla la un mom de timp in set_nod_cost, inseamna ca acele noduri nu au fost inca procesate.
    set_cost_nod.insert(make_pair(0, sursa)); // cost 0 pt nodul sursa 1
    while (!set_cost_nod.empty())
    {
        int nod = (*set_cost_nod.begin()).second; // luam nodul curent
        set_cost_nod.erase(set_cost_nod.begin()); // pop nod crr si cost
        if (visited[nod] == 0)
        {
            visited[nod] = 1;
            for (int i = 0; i < adj[nod].size(); ++i)
            {
                int nod_dest = adj[nod][i].first;             // nod_dest = este nodul destinatie de la care plecam din nodul crr("nod")
                int cost_dest = adj[nod][i].second;           // costul muchiei de la nod la nod_dest
                if (value[nod] + cost_dest < value[nod_dest]) // value[nod] retine dist de la nodul src(1) la nodul crr (nod)
                // adugam costul de la nod crr la nod dest sa vedem daca gasim o cale mai "ieftina" din nodul src(1) la nod dest
                {
                    if (value[nod_dest] != inf)
                    {
                        set_cost_nod.erase(set_cost_nod.find(make_pair(value[nod_dest], nod_dest)));
                        // in cazul in care value[nod_dest] !=inf adica dist din 1 la nod_dest a mai fost actualizata si totusi s-a gasit
                        // un drum mai scurt, vom scoate valoarea veche din set_nod_cost pt a o reactualiza mai jos in value si pt a face push
                        // in set la noua valoare pt nod_dest
                    }
                    // deci se respecta cond din if
                    value[nod_dest] = value[nod] + cost_dest;                  // actualizam noul cost pt nodul dest
                    set_cost_nod.insert(make_pair(value[nod_dest], nod_dest)); // inseram in set (costul de a ajung din src la nod_dest, nod dest)
                    // la urmatoarele iteratii se va lua nod_dest ca fiind noul nod crr
                }
            }
        }
    }
}

int main()
{
    fin >> T;
    for (int i = 1; i <= T; i++)
    {
        fin >> n >> m >> sursa;
        int bronzanel[n + 1];
        for (int j = 1; j <= n; j++){
            fin >> bronzanel[j];
            visited[j]=0;
            value[j]=inf;
        }
        // for (int j = 1; j <= n; j++)
        //     visited[j] = 0;
        // for (int j = 1; j <= n; j++)
        //     value[j] = inf;
        value[sursa] = 0;
        for (int j = 1; j <= m; j++)
        {
            int a, b, c;
            fin >> a >> b >> c;
            adj[a].push_back(make_pair(b, c));
            adj[b].push_back(make_pair(a, c));
        }
        dijkstra(sursa);
        //adj.erase();
        for (int j = 1; j <= n; j++)
            adj[j].erase(adj[j].begin(), adj[j].end());
        bool verif = 1;
        for (int j = 1; j <= n; j++)
            if (value[j] != bronzanel[j])
            {
                verif = 0;
                break;
            }
        if (verif == 1)
            fout << "DA"<<endl;
        else
            fout << "NU"<<endl;
    }
    return 0;
}