#include <iostream>
#include <vector>

/* clang-format off */
static __attribute__((unused)) void redir(const std::string str) { std::freopen((str + ".in").c_str(), "r", stdin); std::freopen((str + ".out").c_str(), "w", stdout); }
static void fast_io() { std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); std::cout.tie(nullptr); }
template<typename T> static void read(T& var) { std::cin >> var; }
template<typename T, typename... Ts> static void read(T& var, Ts&... vars) { read(var); read(vars...); }
/* clang-format on */

static std::vector<std::vector<std::pair<int, int>>> adj;
static std::vector<int> dists;
static std::vector<char> dp;

char dfs(const int src)
{
        if(dp[src] != -1)
        {
                return dp[src];
        }

        std::vector<int> possible_nodes;
        for(const auto& e : adj[src])
        {
                const int u = e.first;
                const int w = e.second;

                if(dists[u] + w == dists[src])
                {
                        possible_nodes.push_back(u);
                }
                if(dists[u] + w < dists[src])
                {
                        dp[src] = 0;
                        return 0;
                }
        }

        char cond = 0;
        for(const int u : possible_nodes)
        {
                if(dfs(u))
                {
                        cond = 1;
                }
        }

        dp[src] = cond;
        return cond;
}

void solve_one()
{
        adj.clear();
        dp.clear();

        int N, M, S;
        read(N, M, S);

        dists.resize(N + 1);
        for(int i = 1; i <= N; ++i)
        {
                read(dists[i]);
        }

        adj.resize(N + 1);
        dp.assign(N + 1, -1);
        for(int i = 0; i < M; ++i)
        {
                int u, v, w;
                read(u, v, w);

                adj[u].push_back({v, w});
                adj[v].push_back({u, w});
        }

        if(dists[S] != 0)
        {
                std::cout << "NU\n";
                return;
        }

        dp[S] = 1;

        for(int v = 1; v <= N; ++v)
        {
                if(dp[v] == -1)
                {
                        dfs(v);
                }

                if(dp[v] == 0)
                {
                        std::cout << "NU\n";
                        return;
                }
        }

        std::cout << "DA\n";
}

int main()
{
        fast_io();
        redir("distante");

        int T;
        read(T);

        while(T--)
        {
                solve_one();
        }
}