#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <tuple>
#include <limits>

#define INF 100000

using namespace std;

void dijkstra(int N, int source, const vector<vector<pair<int, int>>>& adj, vector<int>& dist) {
    dist.assign(N + 1, INF);
    dist[source] = 0;
    
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;
    pq.push({0, source});

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();

        if (d > dist[u]) continue;

        for (const auto& [v, cost] : adj[u]) {
            if (dist[u] + cost < dist[v]) {
                dist[v] = dist[u] + cost;
                pq.push({dist[v], v});
            }
        }
    }
}

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

    int T;
    fin >> T;

    while (T--) {
        int N, M, S;
        fin >> N >> M >> S;

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

        vector<vector<pair<int, int>>> adj(N + 1);

        for (int i = 0; i < M; ++i) {
            int a, b, c;
            fin >> a >> b >> c;
            adj[a].emplace_back(b, c);
            adj[b].emplace_back(a, c);
        }

        vector<int> real;
        dijkstra(N, S, adj, real);

        bool correct = true;
        for (int i = 1; i <= N; ++i) {
            if ((expected[i] == -1 && real[i] != INF) ||
                (expected[i] != -1 && real[i] != expected[i])) {
                correct = false;
                break;
            }
        }

        fout << (correct ? "DA" : "NU") << '\n';
    }

    return 0;
}