"""# ### 谜题描述 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 3 because the letter 'a' appears 3 times. Here is a reference code to solve this task. You can use this to help you genereate cases or validate the solution. ```python from collections import defaultdict as dd, deque input=raw_input range=xrange n,m = map(int,input().split()) s = [ord(c)-ord('a') for c in input()] E = dd(list) P = dd(list) C = [0]*n for i in range(n): E[i] = [] for _ in range(m): a,b = map(int,input().split()) E[a-1].append(b-1) P[b-1].append(a-1) C[a-1] += 1 leafs = [v for v in E if len(E[v])==0] used = [0]*n DP = [[0]*27 for _ in range(n)] for i in range(n): DP[i][s[i]] += 1 Q = deque() for leaf in leafs: Q.append(leaf) while Q: node = Q.pop() #print(node) V = [] for i in range(27): mx = 0 for ch in E[node]: mx = max(mx,DP[ch][i]) DP[node][i] += mx if used[leaf]: continue #for dp in DP: # print(dp[:6]) for pa in P[node]: C[pa] -= 1 if C[pa] == 0: Q.append(pa) if any(C): print(-1) else: print(max(max(dp) for dp in DP)) ``` 请完成上述谜题的训练场环境类实现，包括所有必要的方法。 """ from bootcamp import Basebootcamp import random from collections import deque, defaultdict class Dsubstringbootcamp(Basebootcamp): def __init__(self, **params): self.n = params.get('n', 5) self.m = params.get('m', 4) self.seed = params.get('seed', None) if self.seed is not None: random.seed(self.seed) def case_generator(self): n = self.n m = self.m # 生成每个节点的字母 letters = [chr(random.randint(ord('a'), ord('z'))) for _ in range(n)] s = ''.join(letters) # 生成m条有向边 edges = [] for _ in range(m): x = random.randint(1, n) y = random.randint(1, n) edges.append( (x, y) ) # 检查图中是否存在环 edges_0based = [ (x-1, y-1) for x, y in edges ] if self.has_cycle(n, edges_0based): correct_answer = -1 else: # 计算最长路径的值 correct_answer = self.compute_max_path(n, edges_0based, letters) # 将edges转换为1-based的字符串表示 edges_str = [[str(x), str(y)] for x, y in edges] case = { 'n': n, 'm': m, 's': s, 'edges': edges_str, 'correct_answer': correct_answer } return case def has_cycle(self, n, edges): adj = [[] for _ in range(n)] in_degree = [0] * n for u, v in edges: adj[u].append(v) in_degree[v] += 1 queue = deque() for i in range(n): if in_degree[i] == 0: queue.append(i) count = 0 while queue: u = queue.popleft() count += 1 for v in adj[u]: in_degree[v] -= 1 if in_degree[v] == 0: queue.append(v) return count != n def compute_max_path(self, n, edges, letters): E = defaultdict(list) P = defaultdict(list) C = [0] * n for u, v in edges: E[u].append(v) P[v].append(u) C[u] += 1 leafs = [u for u in E if len(E[u]) == 0] if not leafs: return -1 DP = [ [0]*27 for _ in range(n) ] for i in range(n): c = ord(letters[i]) - ord('a') DP[i][c] = 1 Q = deque(leafs) used = [False] * n while Q: u = Q.popleft() if used[u]: continue used[u] = True for c in range(27): max_val = 0 for v in E[u]: if DP[v][c] > max_val: max_val = DP[v][c] DP[u][c] += max_val for v in P[u]: C[v] -= 1 if C[v] == 0: Q.append(v) if any(c > 0 for c in C): return -1 else: max_value = max(max(row) for row in DP) return max_value @staticmethod def prompt_func(question_case): n = question_case['n'] m = question_case['m'] s = question_case['s'] edges = question_case['edges'] edge_lines = '\n'.join([f"{x} {y}" for x, y in edges]) prompt = f"""You are given a graph with {n} nodes and {m} directed edges. Each node is assigned a lowercase letter, as follows: {s}. The directed edges are: {edge_lines} The value of a path is defined as the highest frequency of any single letter along that path. For example, a path with letters 'abaca' has a value of 3 because 'a' appears three times. Your task is to determine the maximum possible value of any path in this graph. If the graph contains a cycle, making the path infinitely long, output -1. Otherwise, output the maximum value. Please provide your answer within [answer] tags. """ return prompt @staticmethod def extract_output(output): start = output.rfind('[answer]') if start == -1: return None end = output.find('[/answer]', start) if end == -1: return None answer_str = output[start+8:end].strip() if not answer_str: return None try: return int(answer_str) except ValueError: return None @classmethod def _verify_correction(cls, solution, identity): correct_answer = identity['correct_answer'] if solution is None: return False return solution == correct_answer