#include <fstream>
#include <cmath>
#define MAX 50000
#define INF 0x3f3f3f3f

using namespace std;

int n, nh, sursa, dest;

typedef struct nodul{
    int nod, c;
    nodul* urm;
} NOD, *PNOD;

PNOD l[MAX];
int poz[MAX], h[MAX];
int d[MAX], d1[MAX];     

void Add(int i, int j, int cost);
void Dijkstra();
void BuildHeap();
void HeapUp(int k);
void HeapDw(int k, int l);
void Swap(int i, int j);
int ExtractMin();

ofstream fout("distante.out");

int main()
{
    int i, j1, T, j, aux, v, cost, m, v1, v2;
    
    ifstream fin("distante.in");
    fin >> T;
    for (j1 = 1; j1 <= T; j1++)
    {
    fin >> n >> m >> sursa;
    for (i = 1; i <= n; i++)
        fin >> d1[i];
    for (i = 1; i <= m; i++)    
    {
        fin >> v1 >> v2 >> cost;
        Add(v1, v2, cost);
        Add(v2, v1, cost); 
    }

    Dijkstra();
    
    memset(l, 0, sizeof(l));
    
    }    
    
    fin.close();
    fout.close();
    
    return 0;
}

void Add(int i, int j, int cost)
{
    PNOD p = new NOD;
    p->nod = j;
    p->c = cost;
    p->urm = l[i];
    l[i] = p;
}

void Dijkstra()
{
    int i, j, dist;
    PNOD p;
    
    for (i = 1; i <= n; i++)    
    {
        d[i] = INF;
        h[i] = i, poz[i] = i;    
    }
    
    nh = n;
    d[sursa] = 0;
    BuildHeap();
    
    while (nh)
    {
        i = ExtractMin();
        if (d[i] != d1[i])
        {
            fout << "NU\n";
            return;    
        }
        for (p = l[i]; p; p = p->urm)    
        {
             j = p->nod;
             dist = p->c;
             if (d[j] > d[i] + dist)       
             {
                  d[j] = d[i] + dist;
                  HeapUp(poz[j]);             
             }
        }
    }
    fout << "DA\n";
}

void BuildHeap()
{
    int i;
    for (i = 1; i <= n; i++)    
        HeapUp(i);
}

void HeapUp(int k)
{
    if (k == 1) return;
    int tata = k/2;
    if (d[h[k]] < d[h[tata]])    
    {
        Swap(k, tata);
        HeapUp(tata);    
    }
}

void HeapDw(int k, int l)
{
    if (2*k <= l)
    {
        int i = 2*k;
        if (i+1 <= l && d[h[i]] > d[h[i+1]]) i++;
        if (d[h[k]] > d[h[i]])    
        {
            Swap(k, i);
            HeapDw(i, l);        
        }
    }
}

void Swap(int i, int j)
{
    int aux = h[i]; h[i] = h[j]; h[j] = aux;
    poz[h[i]] = i; poz[h[j]] = j;    
}

int ExtractMin()
{
    int min = h[1];
    Swap(1, nh);
    poz[h[nh]] = 0;
    nh--;
    HeapDw(1, nh);
    
    return min;    
}