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

using namespace std;

fstream f("distante.in", ios::in);
fstream g("distante.out", ios::out);

const int INFINITY = (~0) ^ (1 << 31);

struct Edge
{
    int node;
    int cost;
};

class Comparator {
public:
    bool operator() (Edge e1, Edge e2) {
        return e1.cost > e2.cost;
    }
};

void solve() {
    int n, m, source;
    f >> n >> m >> source;

    vector<int> supposedDistance(n + 1);
    for(int i = 1; i <= n; ++i) {
        int d;
        f >> d;
        supposedDistance[i] = d;
    }
    if(supposedDistance[source] != 0) {
        g << "NU\n";
        return;
    }
    vector<Edge> edges[n + 1];
    for(int i = 0; i < m; ++i) {
        int a, b, c;
        f >> a >> b >> c;
        edges[a].push_back(Edge{b, c});
        edges[b].push_back(Edge{a, c});
    }

    priority_queue<Edge, vector<Edge>, Comparator> bestNodeQueue;

    vector<int> distance(n + 1, INFINITY);
    distance[source] = 0;
    vector<bool> visited(n + 1, false);
    visited[source] = true;

    for(Edge& edge : edges[source]) {
        bestNodeQueue.push(edge);
        distance[edge.node] = edge.cost;
    }

    while(!bestNodeQueue.empty()) {
        int node = bestNodeQueue.top().node;
        int cost = bestNodeQueue.top().cost;
        bestNodeQueue.pop();
        if(visited[node]) {
            continue;
        }
        if(supposedDistance[node] != cost) {
            g << "NU\n";
            return;
        }
        visited[node] = true;
        for(Edge& edge : edges[node]) {
            if(cost + edge.cost < distance[edge.node]) {
                bestNodeQueue.push(Edge{edge.node, cost + edge.cost});
                distance[edge.node] = cost + edge.cost;
            }
        }
    }

    g << "DA\n";
}

int main()
{
    int t;
    f >> t;
    for(int i = 0; i < t; ++i)
    {
        solve();
    }



    return 0;
}