#include <iostream>
#include <fstream>
#include <queue>
#include <vector>
#include <string.h>

#define inf 1e9
#define nm 50002

using namespace std;

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

vector <pair <int, int> > G[nm];
int n , m , T;
int dist_min[nm] , dist_t_min[nm];
int nod_start;
int x , y , c;

class comp
{
public:
    bool operator () (const int &x, const int &y)
    {
        return dist_min[x]>dist_min[y];
    }
};

priority_queue <int , vector<int> , comp> PQ;

void dijkstra();


int drumuri()
{
    for(int i=1; i<=n; ++i)
    {
        if(dist_min[i] != dist_t_min[i])
            return 0;
    }
    return 1;
}


void read()
{
    fin >> T;
    for(int i = 0 ; i < T ; i++)
    {
        fin >> n >> m >> nod_start;
        for (int j = 1 ; j <= n ; j++) fin >> dist_t_min[j];
        for (int j = 0 ; j < m ; j++)
        {
            fin >> x >> y >> c;
            G[x].push_back(make_pair(y , c));
            G[y].push_back(make_pair(x , c));
        }
        dijkstra();
        if(drumuri())
            fout << "DA" << '\n';
        else
            fout << "NU" << '\n';

        for(int j=0; j<=n; ++j)
        {
            G[j].clear();
        }

    }
}

void dijkstra(){
    int varf_min;
    for(int i = 1 ; i <= n ; ++i)  dist_min[i] = inf;
    dist_min[nod_start] = 0;
    PQ.push(nod_start);
    while (PQ.size()){
        varf_min = PQ.top();
        PQ.pop();

        for(int i=0; i<G[varf_min].size(); ++i)
        {
            if(dist_min[G[varf_min][i].first] > dist_min[varf_min] + G[varf_min][i].second)
            {
                dist_min[G[varf_min][i].first] = dist_min[varf_min] + G[varf_min][i].second;
                PQ.push(G[varf_min][i].first);
            }
        }
    }
}

int main() {
    read();

    return 0;
}