#include <fstream>
#include <vector>
#include <queue>
#define INF 99999999

using namespace std;

ifstream fin("distante.in");
ofstream fout("distante.out");

int task;
int N,M;
int source;
int model[50002];

struct Nod
{
   vector <int> Ad;
   vector <int> Cost;
};

vector <Nod> Graf;

int dist[50002];
bool v[50002];

void Init()
{
  for(int i=1; i<=N; ++i)
    dist[i]=INF,
    v[i]=0;

  dist[source]=0;

  Graf.clear();

  Nod aux;

  for(int i=0; i<=N; ++i)
    Graf.push_back(aux);
}

void Dijkstra();
void Cecheraut();

void Read()
{
  fin>>task;

  for(int i=1; i<=task; ++i)
  {
    fin>>N>>M>>source;

    for(int j=1; j<=N; ++j)
      fin>>model[j];

    Init();

    int a,b,d;

    for(int j=1; j<=M; ++j)
    {
      fin>>a>>b>>d;

      Graf[a].Ad.push_back(b);
      Graf[a].Cost.push_back(d);

      Graf[b].Ad.push_back(a);
      Graf[b].Cost.push_back(d);
    }

    Dijkstra();
    Cecheraut();
  }

  fin.close();
}

void Dijkstra()
{
   priority_queue < pair<int,int>,vector < pair<int,int> >,greater<pair<int,int> > > Heap;

   Heap.push(make_pair(0,source));

   int nod_curent;

   while(!Heap.empty())
   {
     nod_curent=Heap.top().second;

     Heap.pop();

     if(v[nod_curent]) continue;
     else v[nod_curent]=1;

     for(int i=0; i<Graf[nod_curent].Ad.size(); ++i)
       if(dist[Graf[nod_curent].Ad[i]]>dist[nod_curent]+Graf[nod_curent].Cost[i])
       {
         dist[Graf[nod_curent].Ad[i]]=dist[nod_curent]+Graf[nod_curent].Cost[i];

         if(dist[Graf[nod_curent].Ad[i]]<model[Graf[nod_curent].Ad[i]]) return;

         Heap.push(make_pair(dist[Graf[nod_curent].Ad[i]],Graf[nod_curent].Ad[i]));
       }
   }
}

void Cecheraut()
{
  for(int i=1; i<=N; ++i)
    if(model[i]!=dist[i])
      { fout<<"NU"<<'\n';
        return;
      }

  fout<<"DA"<<'\n';
}

int main()
{
    Read();

    return 0;
}