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

     Problem: 1779

     User: idy002

     Language: C++

     Result: Accepted

     Time:36 ms

     Memory:1520 kb

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

 #include <cstdio>

 #include <cstring>

 #include <vector>

 #include <queue>

 #define maxn 4010

 #define fprintf(...)

 #define oo 0x3f3f3f3f

 using namespace std;

 struct Edge {

     int u, v, f;

     Edge( int u, int v, int f ):u(u),v(v),f(f){}

 };

 struct Dinic {

     int src, dst;

     vector<Edge> edge;

     vector<int> g[maxn];

     int dep[maxn], cur[maxn];

     void init( int src, int dst ) {

         this->src = src;

         this->dst = dst;

     }

     void adde( int u, int v, int f ) {

         fprintf( stderr, "%d->%d %d\n", u, v, f );

         g[u].push_back( edge.size() );

         edge.push_back( Edge(u,v,f) );

         g[v].push_back( edge.size() );

         edge.push_back( Edge(v,u,) );

     }

     bool bfs() {

         queue<int> qu;

         memset( dep, , sizeof(dep) );

         qu.push( src );

         dep[src] = ;

         while( !qu.empty() ) {

             int u=qu.front();

             qu.pop();

             for( int t=; t<g[u].size(); t++ ) {

                 Edge &e = edge[g[u][t]];

                 if( e.f && !dep[e.v] ) {

                     dep[e.v] = dep[e.u]+;

                     qu.push( e.v );

                 }

             }

         }

         return dep[dst];

     }

     int dfs( int u, int a ) {

         if( u==dst || a== ) return a;

         int remain=a, past=, na;

         for( int &t=cur[u]; t<g[u].size(); t++ ) {

             Edge &e = edge[g[u][t]];

             Edge &ve = edge[g[u][t]^];

             if( dep[e.v]==dep[e.u]+ && e.f && (na=dfs(e.v,min(e.f,remain))) ) {

                 remain -= na;

                 past += na;

                 e.f -= na;

                 ve.f += na;

                 if( remain== ) break;

             }

         }

         return past;

     }

     int maxflow() {

         int flow=;

         while( bfs() ) {

             memset( cur, , sizeof(cur) );

             flow += dfs(src,oo);

         }

         return flow;

     }

 }D;

 int n, m;

 vector<int> g[maxn];

 int cnt[maxn];

 char stat[maxn];

 int idj[maxn], idt[maxn], ide[maxn][];

 void makeid( int &src, int &dst ) {

     int id_clock = ;

     src = ++id_clock;

     dst = ++id_clock;

     fprintf( stderr, "src=%d dst=%d\n", src, dst );

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

         if( stat[i]=='J' ) {

             idj[i] = ++id_clock;

             fprintf( stderr, "idj[%d] = %d\n", i, idj[i] );

         } else if( stat[i]=='T' ) {

             idt[i] = ++id_clock;

             fprintf( stderr, "idt[%d] = %d\n", i, idt[i] );

         }

         if( stat[i]!='T' ) {

             ide[i][] = ++id_clock;

             ide[i][] = ++id_clock;

             fprintf( stderr, "ide[%d][0] = %d\n", i, ide[i][] );

             fprintf( stderr, "ide[%d][1] = %d\n", i, ide[i][] );

         }

     }

 }

 int main() {

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

     scanf( "%s", stat+ );

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

         cnt[i] = cnt[i-]+(stat[i]=='E');

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

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

         g[u].push_back(v);

         g[v].push_back(u);

     }

     int src, dst;

     makeid( src, dst );

     D.init( src, dst );

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

         if( stat[i]=='J' ) {

             D.adde( src, idj[i],  );

             D.adde( idj[i], ide[i][],  );

             for( int t=; t<g[i].size(); t++ ) {

                 int j=g[i][t];

                 if( stat[j]=='T' ) continue;

                 D.adde( idj[i], ide[j][],  );

             }

         } else if( stat[i]=='T' ) {

             D.adde( idt[i], dst,  );

             for( int t=; t<g[i].size(); t++ ) {

                 int j=g[i][t];

                 if( stat[j]=='T' ) continue;

                 D.adde( ide[j][], idt[i],  );

             }

         }

         if( stat[i]!='T' ) {

             D.adde( ide[i][], ide[i][],  );

         }

     }

     printf( "%d\n", D.maxflow() );

 }