You are given a graph with $n$ nodes and $m$ directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is $3$. Your task is find a path whose value is the largest.
The first line contains two positive integers $n, m$ ($1 \leq n, m \leq 300\,000$), denoting that the graph has $n$ nodes and $m$ directed edges.

The second line contains a string $s$ with only lowercase English letters. The $i$-th character is the letter assigned to the $i$-th node.

Then $m$ lines follow. Each line contains two integers $x, y$ ($1 \leq x, y \leq n$), describing a directed edge from $x$ to $y$. Note that $x$ can be equal to $y$ and there can be multiple edges between $x$ and $y$. Also the graph can be not connected.
In the first sample, the path with largest value is $1 \to 3 \to 4 \to 5$. The value is $3$ because the letter 'a' appears $3$ times.
5 4
abaca
1 2
1 3
3 4
4 5
3
6 6
xzyabc
1 2
3 1
2 3
5 4
4 3
6 4
-1
10 14
xzyzyzyzqx
1 2
2 4
3 5
4 5
2 6
6 8
6 5
2 10
3 9
10 9
4 6
1 10
2 8
3 7
4
1 1
f
1 1
-1
10 50
ebibwbjihv
1 10
1 2
5 4
1 8
9 7
5 6
1 8
8 7
2 6
5 4
1 9
3 2
8 3
5 6
5 9
2 4
2 7
3 9
1 2
1 7
1 10
3 7
1 8
3 10
8 6
1 7
10 6
1 6
5 8
1 5
2 10
3 9
5 8
8 3
3 7
5 2
1 10
1 4
5 3
3 2
1 2
5 8
10 4
2 10
8 2
1 9
1 8
1 2
3 4
1 8
2
13 37
dwpzcppjmhkmz
2 6
3 6
6 7
6 7
6 7
6 7
6 8
6 8
6 8
6 8
4 6
4 6
5 6
4 6
4 6
6 9
6 9
6 10
6 10
6 10
6 10
4 6
1 6
1 6
10 11
6 11
1 6
6 12
6 12
6 12
6 13
6 13
6 13
6 13
3 6
2 6
2 6
3
5 8
tetqw
2 1
4 4
5 5
5 2
4 5
1 5
1 5
1 1
-1
5 8
reeet
4 3
2 5
4 2
2 4
4 2
5 2
3 3
3 4
-1
def calculate(s):
    x={i:s.count(i) for i  in s}
    dict1={k: v for k, v in sorted(x.items(), key=lambda item: item[1])}
    ans=list(dict1.values())
    return ans[-1]


# def dfs(graph,start):
#     max1=-1
#     queue=[start]
#     visited=[start]
#     str1=""
#     while(queue):
#         x=queue.pop(-1)
#         if(graph[x][1]==[]):
#             str1+=graph[x][0]
#             re=calculate(str1)
#             if(re>max1):
#                 max1=re
#             print(str1)
#         else:
#             str1+=graph[x][0]
#         if(x in graph):
#             for i in graph[x][1]:
#                 if(i not in visited):
#                     queue.append(i)
#                     visited.append(i)
#                 else:
#                     continue
#     return max1

max1=-1
def dfs_recursive(graph, vertex, path,str2):
    global max1
    path += [vertex]
    if(graph[vertex][1]==[]):
        str2=str2+graph[vertex][0]
        p=calculate(str2)
        if(p>max1):
            max1=p
        print(str2,p)
        
    for neighbor in graph[vertex][1]:
        if neighbor not in path:
            str2+=graph[vertex][0]
            path = dfs_recursive(graph, neighbor, path,str2)
            str2=str2[0:len(str2)-1]
    return path

n,m=map(int,input().split())
s=str(input())
graph={}
for i in range(0,len(s)):
    graph[i+1]=[s[i],[]]
for i in range(0,m):
    p,q=map(int,input().split())
    graph[p][1].append(q)
dfs_recursive(graph,1,[],"")
print(max1)