/**************************************************************

     Problem: 3926

     User: idy002

     Language: C++

     Result: Accepted

     Time:4320 ms

     Memory:460976 kb

 ****************************************************************/

 #include <cstdio>

 #include <cassert>

 #include <cstring>

 #include <algorithm>

 #define N 100010

 #define ST 3000100

 #define SS ST<<1

 using namespace std;

 typedef long long dnt;

 int qu[SS], stk[SS], bg, ed, top;

 struct Sam {

     int son[SS][], val[SS], pnt[SS], ntot;

     Sam() { pnt[] = -; };

     int append( int p, int c ) {

         int np = ++ntot;

         val[np] = val[p]+;

         while( p!=- && !son[p][c] )

             son[p][c]=np, p=pnt[p];

         if( p==- ) {

             pnt[np] = ;

         } else {

             int q=son[p][c];

             if( val[q]==val[p]+ ) {

                 pnt[np] = q;

             } else {

                 int nq = ++ntot;

                 memcpy( son[nq], son[q], sizeof(son[nq]) );

                 val[nq] = val[p]+;

                 pnt[nq] = pnt[q];

                 pnt[q] = pnt[np] = nq;

                 while( p!=- && son[p][c]==q )

                     son[p][c]=nq, p=pnt[p];

             }

         }

         return np;

     }

     dnt count() {

         dnt rt = ;

         for( int u=; u<=ntot; u++ )

             rt += val[u]-val[pnt[u]];

         return rt;

     }

 }sam;

 struct Trie {

     int son[ST][], last[ST], ntot;

     void insert( int *T ) {

         int u=;

         for( int i=; T[i]!=-; i++ ) {

             int c=T[i];

             if( !(<=T[i]&&T[i]<) ) {

                 assert( T[i]>= && T[i]<= );

             }

             if( !son[u][c] ) son[u][c]=++ntot;

             u=son[u][c];

         }

     }

     void build() {

         last[] = ;

         qu[bg=ed=] = ;

         while( bg<=ed ) {

             int u=qu[bg++];

             for( int c=; c<; c++ ) {

                 int v=son[u][c];

                 if( !v ) continue;

                 last[v] = sam.append( last[u], c );

                 qu[++ed] = v;

             }

         }

     }

 }trie;

 int n, c;

 int head[N], wght[N], dest[N<<], next[N<<], etot;

 int dgr[N], fat[N];

 void adde( int u, int v ) {

     etot++;

     dest[etot] = v;

     next[etot] = head[u];

     head[u] = etot;

 }

 void bfs( int s ) {

     qu[bg=ed=] = s;

     fat[s] = ;

     while( bg<=ed ) {

         int u=qu[bg++];

         for( int t=head[u]; t; t=next[t] ) {

             int v=dest[t];

             if( v==fat[u] ) continue;

             qu[++ed] = v;

             fat[v] = u;

         }

     }

     for( int t=; t<=top; t++ ) {

         int u=stk[t];

         bg=, ed=;

         while( u ) {

             qu[++ed] = wght[u];

             u=fat[u];

         }

         reverse( qu+, qu++ed );

         qu[++ed] = -;

         trie.insert( qu+ );

     }

 }

 int main() {

     scanf( "%d%d", &n, &c );

     for( int i=; i<=n; i++ )

         scanf( "%d", wght+i );

     for( int i=,u,v; i<n; i++ ) {

         scanf( "%d%d", &u, &v );

         adde( u, v );

         adde( v, u );

         dgr[u]++, dgr[v]++;

     }

     for( int u=; u<=n; u++ )

         if( dgr[u]<= ) stk[++top] = u;

     for( int t=; t<=top; t++ )

         bfs(stk[t]);

     trie.build();

     printf( "%lld\n", sam.count() );

     return ;

 }