#include <fstream>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <string.h>

using namespace std;

#define ll long long
#define pb push_back
#define pii pair<int, int>
#define bg begin
#define en end
#define cl clear
#define x first
#define y second

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

const int NMAX = 50005;
const int INF = 1e9;
const char nl = '\n';

int q, n, m, source, distancias[NMAX], dist[NMAX], inq[NMAX];

vector <pii> v[NMAX];

struct distante{
    int first, second;
    bool operator < (const distante &num) const
    {
        return first > num.first;
    }
};

void solve(){
    in >> n >> m >> source;
    memset(dist, 0, sizeof(dist));
    memset(distancias, 0, sizeof(dist));
    memset(inq, 0, sizeof(dist));
    for(int i = 1; i <= n; ++i)
        in >> distancias[i];
    for(int i = 1; i <= m; ++i){
        int a, b, c;
        in >> a >> b >> c;
        v[a].pb({b, c});
        v[b].pb({a, c});
    }
    for(int i = 1; i <= n; ++i)
        dist[i] = INF;
    dist[source] = 0;
    priority_queue<distante> pq;
    pq.push({0, source});
    while(!pq.empty()){
        int cur_node = pq.top().y;
        int cur_weight = pq.top().x;
        pq.pop();
        if(cur_weight > dist[cur_node]){
            pq.pop();
            continue;
        }
        for(auto neigh: v[cur_node]){
            if(dist[neigh.x] > dist[cur_node] + neigh.y){
                dist[neigh.x] = dist[cur_node] + neigh.y;
                pq.push({dist[neigh.x], neigh.x});
            }
        }
    }
    for(int i = 1; i <= n; ++i){
        if(dist[i] != distancias[i]){
            out << "NU" << nl;
            return;
        }
    }
    out << "DA" << nl;
}

int main()
{
    in >> q;
    while(q--){
        solve();
    }
    return 0;
}