///DISTANTE
#include<fstream>
#include<vector>
#include<list>
#include<limits>
#include<queue>

using namespace std;

const unsigned INF = numeric_limits<unsigned>::max();
typedef pair<unsigned, unsigned> NODE;

void dijkstra(vector<list<NODE> >& adjList,
              vector<unsigned>& dist,
              unsigned source) {
    unsigned numNodes = adjList.size();
    priority_queue<NODE, vector<NODE>, greater<NODE> > nodes;
    list<NODE>::iterator it;
    unsigned currNeigh, currDist, alt;
    dist.assign(numNodes, INF);
    dist[source] = 0;
    nodes.push(NODE(dist[source], source));

    unsigned current;
    while(!nodes.empty()) {
        if(nodes.top().first != dist[nodes.top().second])
            nodes.pop();

        current = nodes.top().second;
        nodes.pop();

        for(it = adjList[current].begin(); it != adjList[current].end(); it++) {
            currNeigh = it->second;
            currDist = it->first;
            alt = dist[current] + currDist;

            if(alt < dist[currNeigh]) {
                dist[currNeigh] = alt;
                nodes.push(NODE(dist[currNeigh], currNeigh));
            }
        }
    }
}

int main() {
    ifstream finStr("distante.in");
    ofstream foutStr("distante.out");

    int T;
    finStr>>T;

    while(T--) {

        unsigned numNodes, numEdges, source;
        vector<unsigned> dist, test;
        vector<list<NODE> > adjList;

        finStr >> numNodes >> numEdges >> source; source--;
        test.resize(numNodes);
        adjList.resize(numNodes);
        for(unsigned i=0; i<numNodes; i++)
            finStr >> test[i];

        unsigned from, to, cost;
        for(unsigned i=0; i<numEdges; i++) {
            finStr >> from >> to >> cost;
            adjList[from-1].push_back(NODE(cost, to-1));
            adjList[to-1].push_back(NODE(cost, from-1));
        }

        dijkstra(adjList, dist, source);
        if(test == dist)
            foutStr << "DA\n";
        else
            foutStr << "NU\n";

    }

    return 0;
}