#include <bits/stdc++.h>

using namespace std;

/// pentru a rezolva problema vom folosi algoritmul lui Dijkstra pentru a afla
/// distanta minima de la nodul sursa la restul nodurilor

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

int n, m, s;
vector<vector<pair<int, int>>> g; /// graful reprezentat prin lista de adiacenta

vector<int> bronzarel;

vector<int> dijkstra(const int s) { /// functie luata din clasa mea de grafuri

    const int INF = 0x3f3f3f3f;
    priority_queue< pair<int, int>, vector <pair<int, int> > , greater<pair<int, int> > > pq;
    vector<int> dist(n + 1, INF);
    vector<bool>inHeap(n + 1, false);


    pq.push(make_pair(0, s));
    dist[s] = 0;

    while (!pq.empty()){
        int node = pq.top().second;
        pq.pop();

        if (!inHeap[node]) {
            inHeap[node] = true;
            for(auto v : g[node])
                if (dist[v.first] > dist[node] + v.second){
                    dist[v.first] = dist[node] + v.second;
                    pq.push(make_pair(dist[v.first], v.first));
            }
        }
    }

    return dist;
}

void verifica(vector<int> &v1, vector<int> &v2)
{
    for(int i = 1; i <= n; i ++)
        if(v1[i] != v2[i])
        {
            fout << "NU\n";
            return;
        }
    fout << "DA\n";

}

void citire()
{
    fin >> n >> m >> s;

    bronzarel.clear();
    bronzarel.shrink_to_fit();
    bronzarel.push_back(0);

    for(int j = 1; j <= n; j ++)
    {
        int x;
        fin >> x;
        bronzarel.push_back(x);
    }

    g.clear();
    g.resize(n + 1);

    for(int j = 1; j <= m; j ++)
    {
        int x, y, z;
        fin >> x >> y >> z;
        g[x].push_back(make_pair(y, z));
        g[y].push_back(make_pair(x, z));
    }
}

int main()
{
    int t;

    fin >> t;

    for(int i = 1; i <= t; i ++)
    {
        vector<int> dist;

        citire();
        dist = dijkstra(s);
        verifica(bronzarel, dist);
    }

    fin.close();
    fout.close();

    return 0;
}