#include<fstream>
#include<vector>
#include<queue>
using namespace std;

#define INF 0x3f3f3f3f

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

vector<vector<pair<int, int> > > G;
vector<long> M;

bool sel[50005]; 
vector<long> sol;

int t, n, m, s;

void Read();
void Solve();

int main()
{
    Read();
    
    fin.close();
    fout.close();
    
    return 0;
}

void Read()
{
     fin >> t;
     for( int e = 1; e <= t; ++e )
     {
          fin >> n >> m >> s;
          G.resize(n+1);
          M.resize(n+1);
          sol.resize(n+1);
          for( int i = 1 ; i <= n; ++i )
          {
               fin >> M[i];
               sol[i] = INF;
               sel[i] = false;
          }
               
          int x, y, c;
          for( int i = 1; i <= m; ++i )
          {
               fin >> x >> y >> c;
               G[x].push_back( make_pair( y, c) );
               G[y].push_back( make_pair( x, c) );
          }
          Solve();
     }
}

void Solve()
{    
     sel[s] = true;
     sol[s] = 0;
     /*
     if( sol[s] != M[s] )
     {
         fout << "NU" << '\n';
         M.clear();
         return;
     }
     */
     for( int i = 0; i < G[s].size(); ++i )
          sol[ G[s][i].first ] = G[s][i].second;
     
     int minim, i1;
          
     for( int p = 1; p <= n-1; ++p )
     {
          minim = INF;
          for( int i = 1; i <= n; ++i )
               if( !sel[i] && sol[i] < minim )
               {
                   minim = sol[i];
                   i1 = i;
               }
          
          //fout << i1 << ' ';
          sel[i1] = true;
          /*
          if( sol[i1] != M[i1] )
          {
              fout << "NU" << '\n';
              M.clear();
              return;
          }
          */
          for( int j = 0; j < G[i1].size(); ++j )
               if( !sel[ G[i1][j].first ] && sol[ G[i1][j].first ] > sol[i1] + G[i1][j].second )
                   sol[ G[i1][j].first ] = sol[i1] + G[i1][j].second;
     }
     for( int i = 1; i <= n; ++i )
          if( sol[i] != M[i] )
          {
              fout << "NU" << '\n';
              M.clear();
              return;
          }
     fout << "DA" <<'\n';
     
     M.clear();
}