#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MAXN = 300300;

vector<int> G[MAXN];

long long dp0[MAXN];
vector<long long> dp1[MAXN];

// abb
void dfs1(int v, int p) {
    vector<pair<long long, long long>> children;
    for (int u : G[v]) {
        if (u == p)
            continue;
        dfs1(u, v);
        long long mx1 = 0;
        long long mx2 = 0;
        for (int k = 0; k < dp1[u].size(); ++k) {
            mx1 = max(mx1, dp1[u][k] + k);
            mx2 = max(mx2, dp1[u][k] + int(dp1[u].size()) - 1 - k);
        }
        children.emplace_back(mx2, dp0[u]);
        dp0[v] += max(mx1, dp0[u]);
    }
    sort(children.begin(), children.end(), [](const pair<long long, long long>& a, const pair<long long, long long>& b) {
        return a.first - a.second > b.first - b.second;
    });
    dp1[v].resize(children.size() + 1);
    for (int i = 0; i < children.size(); ++i)
        dp1[v][0] += children[i].second;
    for (int i = 0; i < children.size(); ++i) {
        dp1[v][i + 1] = dp1[v][i] + children[i].first - children[i].second;
    }
    for (int i = 0; i <= children.size(); ++i)
        dp1[v][i] += i * 1ll * (int(children.size()) - i);
}

// aba
void dfs2(int v, int p) {
    vector<pair<long long, long long>> children;
    for (int u : G[v]) {
        if (u == p)
            continue;
        dfs2(u, v);
        long long mx1 = 0;
        long long mx2 = 0;
        for (int k = 0; k < dp1[u].size(); ++k) {
            mx1 = max(mx1, dp1[u][k] + 2 * k);
            mx2 = max(mx2, dp1[u][k]);
        }
        children.emplace_back(dp0[u], mx2);
        dp0[v] += max(mx1, dp0[u]);
    }
    sort(children.begin(), children.end(), [](const pair<long long, long long>& a, const pair<long long, long long>& b) {
        return a.first - a.second > b.first - b.second;
    });
    dp1[v].resize(children.size() + 1);
    for (int i = 0; i < children.size(); ++i)
        dp1[v][0] += children[i].second;
    for (int i = 0; i < children.size(); ++i) {
        dp1[v][i + 1] = dp1[v][i] + children[i].first - children[i].second;
    }
    for (int i = 0; i <= children.size(); ++i) {
        dp1[v][i] += i * 1ll * (i - 1);
    }
}

// abc
void dfs3(int v, int p) {
    vector<pair<long long, long long>> children;
    for (int u : G[v]) {
        if (u == p)
            continue;
        dfs3(u, v);
        long long mx1 = 0;
        long long mx2 = 0;
        for (int k = 0; k < dp1[u].size(); ++k) {
            mx1 = max(mx1, dp1[u][k] + k);
            mx2 = max(mx2, dp1[u][k]);
        }
        children.emplace_back(mx2, dp0[u]);
        dp0[v] += max(mx1, dp0[u]);
    }
    sort(children.begin(), children.end(), [](const pair<long long, long long>& a, const pair<long long, long long>& b) {
        return a.first - a.second > b.first - b.second;
    });
    dp1[v].resize(children.size() + 1);
    long long cur = 0;
    for (int i = 0; i < children.size(); ++i)
        cur += children[i].second;
    dp1[v][0] = cur;
    for (int i = 0; i < children.size(); ++i) {
        cur += children[i].first - children[i].second;
        int cnt = i + 1;
        dp1[v][(cnt + 1) / 2] = max(dp1[v][(cnt + 1) / 2], cur + (cnt + 1) / 2 * 1ll * (cnt - (cnt + 1) / 2));
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n;
    cin >> n;
    string s;
    cin >> s;
    for (int i = 1; i < n; ++i) {
        int a, b;
        cin >> a >> b;
        G[a - 1].emplace_back(b - 1);
        G[b - 1].emplace_back(a - 1);
    }
    if (s.size() == 1) {
        cout << n << '\n';
        return 0;
    }
    if (s.size() == 2) {
        if (s[0] == s[1]) {
            cout << 2 * (n - 1) << '\n';
        } else {
            cout << n - 1 << '\n';
        }
        return 0;
    }
    if (s[0] == s[1] && s[1] == s[2]) {
        // aaa
        long long ans = 0;
        for (int i = 0; i < n; ++i)
            ans += (G[i].size()) * (int(G[i].size()) - 1);
        cout << ans << '\n';
        return 0;
    }
    if (s[0] == s[1] || s[1] == s[2]) {
        // abb
        dfs1(0, -1);
        long long ans = dp0[0];
        for (long long x : dp1[0])
            ans = max(ans, x);
        cout << ans << '\n';
        return 0;
    }
    if (s[0] == s[2]) {
        // aba
        dfs2(0, -1);
        long long ans = dp0[0];
        for (long long x : dp1[0])
            ans = max(ans, x);
        cout << ans << '\n';
        return 0;
    }
    // abc
        dfs3(0, -1);
        long long ans = dp0[0];
        for (long long x : dp1[0])
            ans = max(ans, x);
        cout << ans << '\n';
    return 0;
}