#include <fstream>
#include <vector>
using namespace std;
//using vit = vector< pair<int, int> >::iterator
#define mp make_pair
#define pb push_back
#define Nmax 50001

int n, s;

vector< pair<int, int> > G[Nmax];
int d[Nmax], dcomp[Nmax];
int heap[Nmax], poz[Nmax], nr;

void read() ;
void dijkstra() ;
void push_heap(int) ;
int get_min() ;

int main()
{
    freopen("distante.in", "r", stdin);
    freopen("distante.out", "w", stdout);

    int i, t;
    bool ok;

    for(scanf("%d", &t); t; --t)
    {
        read();
        
        for(i = 1; i <= n; ++i) d[i] = -1;
        dijkstra();
        
        for(ok = 1, i = 1; i <= n; ++i)
            if(d[i] != dcomp[i]) ok = 0;
        
        if(ok) printf("DA\n");
        else printf("NU\n");
        
        for(i = 1; i <= n; ++i) G[i].clear();
    }
    return 0;
}

void read()
{
    int m, a, b, c;

    scanf("%d %d %d", &n, &m, &s);
    for(int i = 1; i <= n; ++i) scanf("%d", dcomp + i);

    for(; m; --m)
    {
        scanf("%d %d %d", &a, &b, &c);
        G[a].pb( mp(b, c) );
        G[b].pb( mp(a, c) );
    }
}

void dijkstra()
{
    int nod;
    vector< pair<int, int> >::iterator it;
    
    for(nr = 0, d[s] = 0, push_heap(s); nr > 0; )
    {
        nod = get_min();
        for(it = G[nod].begin(); it != G[nod].end(); ++it)
            if((d[it -> first] == -1) || (d[nod] + (it -> second) < d[it -> first]))
        {
            d[it -> first] = d[nod] + (it -> second);
            push_heap(it -> first);
        }
    }
}

void push_heap(int nod)
{
    if(poz[nod] == 0) {heap[++nr] = nod; poz[nod] = nr;}
    
    for(int p = poz[nod]; p > 1; p /= 2)
        if(d[heap[p]] < d[heap[p / 2]])
        {
            swap(heap[p], heap[p / 2]);
            swap(poz[heap[p]], poz[heap[p / 2]]);
        }
        else return;
}

int get_min()
{
    int nod = heap[1]; poz[heap[1]] = 0;
    
    heap[1] = heap[nr]; heap[nr] = 0; --nr;
    poz[heap[1]] = 1;
    
    int p, fiu;
    for(p = 1; 2 * p <= nr; p = fiu)
    {
        fiu = p;
        
        if(d[heap[2 * p]] < d[heap[fiu]]) fiu = 2 * p;
        if(d[heap[2 * p + 1]] < d[heap[fiu]]) fiu = 2 * p + 1;
        
        if(fiu == p) return nod;
    }
    
    return nod;
}