#include <iostream>
#include <fstream>
#include <bits/stdc++.h>

using namespace std;

ifstream f("distante.in");
ofstream g("distante.out");

typedef pair<int, int> per;
const long long inf = 2000000000;

class Graf{
    int numar_noduri;
    int numar_muchii;
    vector<vector<int>> vecini;
public:

    Graf(){
        numar_muchii = 0;
        numar_noduri = 0;
    };

    void seteaza_nr_noduri(int);
    void seteaza_nr_muchii(int);
    void redimensioneaza(int);
    void adauga_muchie(int,int);
    void bfs(int);
    void dfs(vector<bool>&,int);
    int numar_componente_conexe();
    void dfs_topo(vector<bool>&, int, vector<int>&);
    void sortare_topologica(vector<int>&);
    void componente_tare_conexe(Graf&, int&, vector<vector<int>>&);
    void dfs_comp(vector<bool>&, int, vector<vector<int>>&, int);
    void biconex(int&, vector<vector<int>>&);
    void dfs_biconex(vector<bool>&, int, int, vector<int>&, vector<int>&, stack<int>&, vector<vector<int>>&, int&);
    void muchii_critice(int&, vector<vector<int>>&);
    void dfs_muchii_critice(vector<bool>&,int, int, vector<int>&, vector<int>&, vector<vector<int>>&, int&);
    void dijkstra(vector<vector<per>> &, vector<int> &, int);
    void prim(vector<vector<per>>&, int&, vector<per>&);
    void roy_floyd(int d[101][101]);
    void dfs_darb(vector<bool> &, int, int , int &, int &);
    void reseteaza_vizitat(vector<bool> &);
    int darb();
};

void Graf::seteaza_nr_noduri(int numar_noduri){
    this->numar_noduri = numar_noduri;
}

void Graf::seteaza_nr_muchii(int numar_muchii){
    this->numar_muchii = numar_muchii;
}

void Graf::redimensioneaza(int n){
    vecini.resize(n+1);
}

void Graf::adauga_muchie(int n1, int n2){
    vecini[n1].push_back(n2);
}


void  Graf::dijkstra(vector<vector<per>> &vecini_cost, vector<int> &d, int nod_start){
    priority_queue<per, vector<per>, greater<per>> pq;
    vector<bool> vizitat(numar_noduri+1,false);
    vizitat.resize(numar_noduri+1);
    d[nod_start] = 0;
    vizitat[nod_start] = true;

    for(int i = 0; i < vecini_cost[nod_start].size(); i++){
        d[vecini_cost[nod_start][i].second] = vecini_cost[nod_start][i].first;
        pq.push(vecini_cost[nod_start][i]);
    }

    while(pq.size() != 0){
        int nod_curent = pq.top().second;
        pq.pop();
        if(vizitat[nod_curent] == false){
            for(int i = 0; i < vecini_cost[nod_curent].size(); i++)
                if(vizitat[vecini_cost[nod_curent][i].second] == false)
                    if(d[nod_curent] + vecini_cost[nod_curent][i].first < d[vecini_cost[nod_curent][i].second]){
                        d[vecini_cost[nod_curent][i].second] = d[nod_curent] + vecini_cost[nod_curent][i].first;
                        pq.push(make_pair(d[vecini_cost[nod_curent][i].second],vecini_cost[nod_curent][i].second));
                    }
        }
        vizitat[nod_curent] = true;
    }
}

int main(){

    int nr_teste, nod_start, numar_noduri, numar_muchii;

    f >> nr_teste;



    for(int k = 1; k <= nr_teste; k++){

        Graf a;

        f >> numar_noduri;
        a.seteaza_nr_noduri(numar_noduri);

        f >> numar_muchii;
        a.seteaza_nr_muchii(numar_muchii);

        f >> nod_start;

        vector<int> dist_calc(numar_noduri+1);
        for(int i = 1; i <= numar_noduri; i++)
            f >> dist_calc[i];

        vector<vector<per>> vecini_cost;
        vecini_cost.resize(numar_noduri+1);

        for(int i = 1; i <= numar_muchii; i++){
            int nod1; f>>nod1;
            int nod2; f>>nod2;
            int cost; f>>cost;
            vecini_cost[nod1].push_back(make_pair(cost,nod2));
        }

        vector<int> d(numar_noduri+1,inf);

        a.dijkstra(vecini_cost,d, nod_start);

        ///for(int i = 1; i < numar_noduri + 1; i++) cout<<d[i]<<" ";

        int i = 1;
        while( i <= numar_noduri and dist_calc[i] == d[i]) i++;
        if( i > numar_noduri) g<<"DA\n";
        else g<<"NU\n";

        vecini_cost.clear();
        d.clear();
        dist_calc.clear();
    }

    return 0;
}