#include <bits/stdc++.h>
#define MAX 131072

using namespace std;
const int NMAX = 50010;
const int EMAX = 100010;

FILE *IN;

struct edge{
    int x, cost;
};
struct vect{
    vector <edge> edges[EMAX];
}v[11];

int N, M, T, Source, heapSize;
int poz[NMAX], val[NMAX], st[NMAX], heap[NMAX];
int ans[NMAX], valid[NMAX];
bool use[NMAX], add[NMAX];

int pos, sign;
char f[MAX];

inline void Read(int &nr){
    sign = 0;
    nr = 0;
    while(f[pos] < '0' || f[pos] > '9'){
        if(f[pos] == '-') sign = 1;
        pos++;
        if(pos == MAX)
            fread(f, MAX, 1, IN), pos = 0;
    }
    while(f[pos] >= '0' && f[pos] <= '9'){
        nr = 10 * nr + f[pos++] - '0';
        if(pos == MAX)
            fread(f, MAX, 1, IN), pos = 0;
    }
    if(sign) nr =- nr;
}

inline void Swap(int x, int y){
    swap(heap[x], heap[y]);
    poz[heap[x]] = x;
    poz[heap[y]] = y;
}

void upHeap(int node){
    int s = node / 2;
    if(val[heap[node]] < val[heap[s]] && node > 1){
        Swap(node, s);
        upHeap(s);
    }
}

void downHeap(int node){
    int s = 2 * node;
    if(s > heapSize)
        return;
    if(s < heapSize && val[heap[s]] > val[heap[s + 1]]) s++;
    if(val[heap[node]] > val[heap[s]]){
        Swap(node, s);
        downHeap(s);
    }
}

inline void dijkstra(int p){
    heapSize = 0;

    Read(N); Read(M); Read(Source);
    for(int i = 1; i <= N; i++){
        Read(valid[i]);
        val[i] = 2e9;
        add[i] = use[i] = false;
        poz[i] = 0;
    }
    int X, Y, Cost;
    for(int i = 1; i <= M; i++){
        Read(X); Read(Y); Read(Cost);
        v[p].edges[X].push_back({Y, Cost});
        v[p].edges[Y].push_back({X, Cost});
    }

    int Min, node, nrNodes = 0;
    add[Source] = true;
    for(int i = 1; i <= N; i++){
        if(heapSize > 0){
            node = heap[1];
            Min = val[node];
            Swap(1, heapSize);
            heapSize--;
            downHeap(1);
            poz[node] = 0;
            val[node] = 2e9;
        } else Min = 0, node = Source;

        use[node] = true;
        ans[node] = Min;
        for(int j = 0; j < v[p].edges[node].size(); j++){
            int P = v[p].edges[node][j].x;
            int C = v[p].edges[node][j].cost;
            if(!add[v[p].edges[node][j].x]){
                heapSize++;
                heap[heapSize] = v[p].edges[node][j].x;
                val[heap[heapSize]] = ans[node] + v[p].edges[node][j].cost;
                poz[heap[heapSize]] = heapSize;
                add[heap[heapSize]] = true;
                upHeap(heapSize);
            } else if(!use[v[p].edges[node][j].x] && val[v[p].edges[node][j].x] > ans[node] + v[p].edges[node][j].cost){
                val[v[p].edges[node][j].x] = ans[node] + v[p].edges[node][j].cost;
                upHeap(poz[v[p].edges[node][j].x]);
            }
        }
    }

    bool ok = true;
    for(int i = 1; i <= N; i++)
        if(valid[i] != ans[i])
            ok = false;

    if(ok)
        printf("DA\n");
    else printf("NU\n");
}

int main(){

    IN = fopen("distante.in", "r");
    freopen("distante.out", "w", stdout);

    Read(T);
    for(int i = 1; i <= T; i++)
        dijkstra(i);

    return 0;
}

//-41801