#include <bits/stdc++.h>

using namespace std;

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

void dijkstra ( int source, 
                vector<int> &d,
                vector<vector<pair<int, int>>> &adj) {
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

    d[source] = 0;
    pq.push({0, source});
    while (!pq.empty()) {
        int dist = pq.top().first;
        int node = pq.top().second;
        pq.pop();

        if (dist > d[node]) {
            continue;
        }

        int neigh, cost;
        for (auto edge : adj[node]) {
            neigh = edge.first;
            cost = edge.second;
            if (d[neigh] == INT_MAX || d[neigh] > d[node] + cost) {
                d[neigh] = d[node] + cost;
                pq.push({d[neigh], neigh});
            }
        }
    }
}

int main() {
    int T;
    fin >> T;

    for (int i = 1; i <= T; i++) {
        int n, m, source;
        fin >> n >> m >> source;

        vector<int> given_dist (n + 1);
        for (int i = 1; i <= n; i++) {
            fin >> given_dist[i];
        }

        vector<vector<pair<int, int>>> adj(n + 1, vector<pair<int, int>>());
        for (int j = 1, x, y, c; j <= m; j++) {
            fin >> x >> y >> c;
            adj[x].push_back({y, c});
            adj[y].push_back({x, c});
        }
        // dist minime de la source la restul nodurilor
        // costuri pozitive => Dijkstra
        // grafurile sunt conexe

        vector<int> d(n + 1, INT_MAX);
        dijkstra(source, d, adj);

        int check = true;
        for (int j = 1; j <= n; j++) {
            if (given_dist[j] != d[j]) {
                check = false;
                break;
            }
        }
        fout << (check ? "DA" : "NU") << "\n";
    }

    return 0;
}