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

using namespace std;

int n, nh, sursa, dest;

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

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

ofstream fout("distante.out");

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

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

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

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

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

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

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(nh);
    
    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";     
}

int main()
{
    int i, j1, T, 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;
}