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.
Input
The first line contains two positive integers n, m (1 ≤ n, m ≤ 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 ≤ x, y ≤ 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.
Output
Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead.
Examples
Input
5 4 abaca 1 2 1 3 3 4 4 5
Output
3
Input
6 6 xzyabc 1 2 3 1 2 3 5 4 4 3 6 4
Output
-1
Input
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
Output
4
Note
In the first sample, the path with largest value is 1 → 3 → 4 → 5. The value is 3because the letter 'a' appears 3 times.
题意：给你长度为n的字符串， 第i个字符的编号为i；m个关系；
问你在给你的关系图中，最大的价值是多少；最大价值取决于树上路径的最多的同一字符的个数；
你需要注意的是假如所给关系中存在环的话，那么路径上的价值就会是无穷大，此时你需要判断一下该图是否存在环，存在就输出-1；否者输出最大价值；
这个环的判断当然是拓扑排序一下就知道；所以难点是最大价值怎么求；我觉得我的做法就是一种比较暴力的dp；树上的dp，其实不是很难，难的是你能不能想到状态转移方程；我个人觉得树上的dp比一般dp简单的多，也好理解得多；
你想， 当前节点的值，是不是只能有他的父亲节点的状态转移过来；直接看代码吧；注释很清楚了；
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <cstring>
#include <string>
#include <queue>
using namespace std;
typedef long long LL;
const int maxn = 3e5 + 5;
int n ,m;
char a[maxn]; //存放字符
int ind[maxn]; //每个点的入度，接下来会有拓扑排序
int dp[maxn][30]; //转移 第二维是26种字符的转移状态
vector <int> v[maxn]; //建树
bool topsort() //拓扑排序
{
queue <int> q;
for(int i = 1; i <= n; i++)
{
if(ind[i] == 0)
{
q.push(i);
dp[i][a[i] - 'a'] ++; //每个点其实状态
ind[i] = -1;
}
}
int f = 0;
while(!q.empty())
{
int x = q.front(); //父节点
f++; //记录树上点的数量，假如有环的话 f会小于n
q.pop();
for(int i = 0;i < (int)v[x].size();i++)
{
int y = v[x][i]; //子节点
ind[y]--;
if(ind[y] == 0)
{
q.push(y);
ind[y] = -1;
}
for(int j = 0;j < 26;j++) //更新26种状态
{
if(a[y] - 'a' == j) //如果当前子节点的字符为j
dp[y][j] = max(dp[y][j], dp[x][j] + 1); //则值会有父亲节点j点的位置 + 1和自己本身的值转移过来
else
dp[y][j] = max(dp[y][j], dp[x][j]); //否者由父亲节点和自己的j位置转移过来
}
}
}
if(f == n) return true; //如果没有环
else return false;
}
int main()
{
scanf("%d %d %s",&n, &m, a + 1);
memset(ind, 0, sizeof(ind));
for(int i = 1;i <= n;i++) v[i].clear();
for(int i = 1;i<= m;i++)
{
int x, y;
scanf("%d %d ",&x, &y);
v[x].push_back(y); //建树
ind[y]++;
}
if(topsort() == 0) printf("-1\n"); //有环
else{
int ans = 0;
for(int i = 1; i <= n;i ++){
for(int j = 0; j < 26;j ++){
ans = max(ans,dp[i][j]); //暴力去跑一边 取最大值
}
}
printf("%d\n",ans);
}
return 0;
}