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

#define INF 2000000000

std::ifstream fin{"distante.in", std::ios::in};
std::ofstream fout{"distante.out", std::ios::out};

// Structura pentru nodurile din coada de priorități
struct pqNode {
    int node; // nodul
    int dist; // distanța până la acest nod
};

// Comparator pentru coada de priorități
struct SmallerPqComparator {
    bool operator()(const pqNode &lhs, const pqNode &rhs) {
        return lhs.dist > rhs.dist;
    }
};

// Funcție care verifică corectitudinea calculului distanțelor minime folosind algoritmul Dijkstra
const char *dijkstraVerif(int n, int m, int src, std::vector<int> &distances) {
    std::vector<std::vector<std::pair<int, int>>> adj(n + 1, std::vector<std::pair<int, int>>{});

    // Citim muchiile și le adăugăm în lista de adiacență
    int x, y, c;
    for (int i = 0; i < m; i++) {
        fin >> x >> y >> c;
        adj[x].push_back(std::make_pair(y, c));
        adj[y].push_back(std::make_pair(x, c));
    }

    // Vector pentru distanțele calculate de algoritmul Dijkstra
    std::vector<int> dist(n + 1, INF);
    dist[src] = 0;

    // Coada de priorități pentru Dijkstra
    pqNode first = {src, 0};
    std::priority_queue<pqNode, std::vector<pqNode>, SmallerPqComparator> pq;
    pq.push(first);

    // Algoritmul Dijkstra
    while (!pq.empty()) {
        pqNode top = pq.top();
        pq.pop();

        // Relaxarea muchiilor
        for (const auto &neigh : adj[top.node]) {
            if (dist[neigh.first] > dist[top.node] + neigh.second) {
                dist[neigh.first] = dist[top.node] + neigh.second;
                pq.push({neigh.first, dist[neigh.first]});
            }
        }
    }

    // Verificăm dacă distanțele calculate de Dijkstra sunt egale cu cele date de Bronzarel
    bool isCompatible = true;
    for (int i = 1; i <= n; i++)
        if (dist[i] != distances[i])
            isCompatible = false;

    // Returnăm "DA" dacă sunt corecte, altfel "NU"
    return isCompatible ? "DA" : "NU";
}

int main(void) {
    int t, val;
    fin >> t; // Citim numărul de grafuri

    while (t) {
        t--;
        std::vector<int> distances;
        int n, m, src;
        fin >> n >> m >> src; // Citim numărul de noduri, muchii și nodul sursă

        distances.push_back(-1); // Indexare de la 1
        for (int i = 1; i <= n; i++) {
            fin >> val;
            distances.push_back(val); // Citim distanțele date de Bronzarel
        }

        // Verificăm corectitudinea distanțelor pentru graful curent și scriem rezultatul în fișier
        fout << dijkstraVerif(n, m, src, distances) << '\n';
    }

    return 0;
}