#include <fstream>
#include <vector>
#include <queue>
#define Nmax 50009
#define Emax 100009
#define INF (1<<30)

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

typedef pair <int, int> edge;
#define x first
#define c second

int n,m,S,T,d[Nmax],x,y,c,verif[Nmax];
vector <edge> G[Nmax];

struct compare {

    bool operator() (const edge &a, const edge &b) const {

        return a.c>b.c;
    }
};

priority_queue <edge, vector<edge>, compare> Q;

void Clearcontent(int n) {

    for (int i=1; i<=n; ++i) G[i].clear();
}

void ReadInput() {

    f>>n>>m>>S;

    for (int i=1; i<=n; ++i) f>>verif[i];

    for (int i=1; i<=m; ++i) {

        f>>x>>y>>c;
        G[x].push_back(edge(y,c));
        G[y].push_back(edge(x,c));
    }

}

void Dijkstra(int source) {

     for (int i=1; i<=n; ++i) d[i]=INF;

    d[source]=0;
    Q.push(edge(source,0));

    while (!Q.empty()) {

        edge aux = Q.top();
        Q.pop();

        int node=aux.x;
        int cost=aux.c;

        if (cost>d[node]) continue;

        for (auto it: G[node]) {

            int x=it.x;
            int c=it.c;

            if (d[x]==INF || d[x]> d[node] + c) {

                d[x] = d[node] + c;
                Q.push( edge( x, d[x]) );
            }
        }
    }

    for (int i=1; i<=n; ++i) if (d[i]==INF) d[i]=0;
}

void Solve() {

    ReadInput();

    Dijkstra(S);

    for (int i=1; i<=n; ++i)
        if (d[i]!=verif[i]) {

            g<<"NU\n";
            Clearcontent(n);
            return;
        }

    g<<"DA\n";

    Clearcontent(n);
}

int main() {

    f>>T;
    for (int i=1; i<=T; ++i)
        Solve();

    f.close(); g.close();
    return 0;
}