def count_covered_ranges(N, P, A):
    mod = 10**9 + 7

    def dfs(node, parent_value):
        if P[node] == 0:
            return [A[node]]

        ranges = dfs(P[node], parent_value)
        if A[node] >= parent_value:
            ranges.append(A[node])
        else:
            ranges.extend([A[node], parent_value])

        ranges.sort()
        merged = [ranges[0]]
        for r in ranges[1:]:
            if merged[-1] == r:
                continue
            if merged[-1] + 1 == r:
                merged[-1] = r
            else:
                merged.append(r)

        return merged

    return sum(len(dfs(i, 0)) for i in range(N)) % mod

INFOSYS//Path covered Ranges✅

MOD = 10**9 + 7

def dfs(node, parent, graph, A, subtree_size, unique_count, unique_elements):
    size = 1
    count = {A[node]: 1}
    
    for neighbor in graph[node]:
        if neighbor != parent:
            child_size, child_count = dfs(neighbor, node, graph, A, subtree_size, unique_count, unique_elements)
            size += child_size
            for key, value in child_count.items():
                count[key] = count.get(key, 0) + value
    
    subtree_size[node] = size
    unique_count[node] = count
    unique_elements[node] = len(count)
    return size, count

def GetAnswer(N, M, C, edges, A):
    graph = [[] for _ in range(N)]
    for u, v in edges:
        graph[u - 1].append(v - 1)
        graph[v - 1].append(u - 1)
    
    subtree_size = [0] * N
    unique_count = [{} for _ in range(N)]
    unique_elements = [0] * N

    dfs(0, -1, graph, A, subtree_size, unique_count, unique_elements)
    
    total_unique = unique_elements[0]
    max_satisfaction_sum = total_unique

    for u, v in edges:
        u -= 1
        v -= 1
        
        if subtree_size[u] < subtree_size[v]:
            u, v = v, u
        
        satisfaction_v = unique_elements[v]
        satisfaction_u = total_unique - satisfaction_v
        
        total_satisfaction = (satisfaction_u + satisfaction_v) % MOD
        max_satisfaction_sum = max(max_satisfaction_sum, total_satisfaction)
    
    return max_satisfaction_sum

def main():
    import sys
    input = sys.stdin.read
    data = input().splitlines()
    idx = 0
    N = int(data[idx].strip())
    idx += 1
    M = int(data[idx].strip())
    idx += 1
    C = int(data[idx].strip())
    idx += 1
    edges = []
    for _ in range(M):
        edges.append(list(map(int, data[idx].strip().split())))
        idx += 1
    A = []
    for _ in range(N):
        A.append(int(data[idx].strip()))
        idx += 1
    result = GetAnswer(N, M, C, edges, A)
    print(result)

if __name__ == "__main__":
    main()

crazy rule//infosys

logest palinfrome // infosys

def mt(N, S, A):
    dp = [float('inf')] * N
    dp[0] = A[0]

    for i in range(N):
        if i + 1 < N:
            dp[i + 1] = min(dp[i + 1], dp[i] + A[i + 1])

        dc = set()
        for j in range(i, N):
            dc.add(S[j])
            if j + 1 < N:
                ndc = dc | {S[j + 1]}
                if len(dc) < len(ndc):
                    dp[j + 1] = min(dp[j + 1], dp[i] + A[j + 1])
            else:
                break

    return dp[N - 1]


import sys

input = sys.stdin.read
data = input().splitlines()
N = int(data[0])
S = data[1]
A = list(map(int, data[2:N + 2]))

print(mt(N, S, A))

import sys
from collections import defaultdict

def calculateAns(N, M, parents, latency, q, queries):
    tree = defaultdict(list)
    for i in range(M):
        tree[parents[i]].append(i + 2)
    
    power = [0] * (N + 1)
    for i in range(1, N + 1):
        if i == 1:
            power[i] = float('inf')
        else:
            parent = parents[i - 2]
            power[i] = latency[i - 1] ^ latency[parent - 1]

    subtree_power = [0] * (N + 1)

    def dfs(node):
        total_power = power[node]
        for child in tree[node]:
            total_power = min(total_power, dfs(child))
        subtree_power[node] = total_power
        return total_power

    dfs(1)

    result = 0
    for query in queries:
        result = (result + subtree_power[query]) % (10**9 + 7)

    return result

def main():
    N = int(sys.stdin.readline().strip())
    M = int(sys.stdin.readline().strip())
    parents = []
    for _ in range(M):
        parents.append(int(sys.stdin.readline().strip()))
    latency = []
    for _ in range(N):
        latency.append(int(sys.stdin.readline().strip()))
    q = int(sys.stdin.readline().strip())
    queries = []
    for _ in range(q):
        queries.append(int(sys.stdin.readline().strip()))
    result = calculateAns(N, M, parents, latency, q, queries)
    print(result)

if __name__ == "__main__":
    main()