#include <bits/extc++.h>
#include <bits/stdc++.h>
using namespace std;

template <typename T>
using ordered_set = __gnu_pbds::tree<T, __gnu_pbds::null_type, less<T>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
#include <experimental/iterator>
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

constexpr int N = 300000 + 5;

vector<int> g[N];

void solve1(int n) {
  cout << n << '\n';
}

void solve2(int n) {
  cout << n - 1 << '\n';
}

void solveAAA(int) {
  auto dfs = [&](auto self, int u, int f) -> int64_t {
    int64_t ret = 0, c = 0;
    for (int v : g[u]) {
      if (v == f)
        continue;
      ret += self(self, v, u);
      c += 1;
    }
    if (u != f)
      ret += c * 2;
    ret += c * (c - 1);
    return ret;
  };
  cout << dfs(dfs, 0, 0) << '\n';
}

void maxi(int64_t &x, int64_t y) {
  x = max(x, y);
}

int64_t dp[N][3][4];

void solveAAB(int) {
  auto dfs = [&](auto self, int u, int f) -> void {
    for (int v : g[u]) {
      if (v != f)
        self(self, v, u);
    }
    for (int x = 0; x < 2; ++x) {
      // 00000 -> 00001 -> 00011 -> ... -> 11111
      int c = 0;
      int64_t sm = 0;
      vector<int64_t> choices;
      for (int v : g[u]) {
        if (v == f)
          continue;
        sm += dp[v][0][x];
        choices.push_back(dp[v][1][x] - dp[v][0][x]);
        c += 1;
      }
      ranges::sort(choices, greater());
      for (int i = 0; i <= ssize(choices); ++i) {
        if (i)
          sm += choices[i - 1];
        const int64_t one = i, zero = c - one;
        if (x == 0) {
          maxi(dp[u][0][0], sm + one * zero + one);
          maxi(dp[u][0][1], sm + one * zero + zero);
          maxi(dp[u][0][2], sm + one * zero);
        } else {
          maxi(dp[u][1][0], sm);
          maxi(dp[u][1][1], sm);
          maxi(dp[u][1][2], sm);
        }
      }
    }
  };
  dfs(dfs, 0, 0);
  cout << max({dp[0][0][2], dp[0][1][2]}) << '\n';
}

void solveABA(int) {
  auto dfs = [&](auto self, int u, int f) -> void {
    for (int v : g[u]) {
      if (v != f)
        self(self, v, u);
    }
    for (int x = 0; x < 2; ++x) {
      // 00000 -> 00001 -> 00011 -> ... -> 11111
      int c = 0;
      int64_t sm = 0;
      vector<int64_t> choices;
      for (int v : g[u]) {
        if (v == f)
          continue;
        sm += dp[v][0][x];
        choices.push_back(dp[v][1][x] - dp[v][0][x]);
        c += 1;
      }
      ranges::sort(choices, greater());
      for (int i = 0; i <= ssize(choices); ++i) {
        if (i)
          sm += choices[i - 1];
        const int64_t one = i, zero = c - one;
        if (x == 0) {
          maxi(dp[u][0][0], sm);
          maxi(dp[u][0][1], sm);
          maxi(dp[u][0][2], sm);
        } else {
          maxi(dp[u][1][0], sm + zero * (zero - 1) + zero * 2);
          maxi(dp[u][1][1], sm + zero * (zero - 1));
          maxi(dp[u][1][2], sm + zero * (zero - 1));
        }
      }
    }
  };
  dfs(dfs, 0, 0);
  cout << max({dp[0][0][2], dp[0][1][2]}) << '\n';
}

void solveABC(int) {
  auto dfs = [&](auto self, int u, int f) -> void {
    for (int v : g[u]) {
      if (v != f)
        self(self, v, u);
    }
    for (int x = 0; x < 3; ++x) {
      if (x != 1) {
        int64_t sm = 0;
        for (int v : g[u]) {
          if (v == f)
            continue;
          sm += max({dp[v][0][x], dp[v][1][x], dp[v][2][x]});
        }
        dp[u][x][0] = dp[u][x][1] = dp[u][x][2] = dp[u][x][3] = sm;
      } else {
        int c0 = 0;
        for (int y : {0, 2, 0}) {
          int64_t sm = 0;
          vector<array<int64_t, 3>> val;
          for (int v : g[u]) {
            if (v == f)
              continue;
            sm += dp[v][2 - y][x];
            val.push_back({dp[v][1][x] - dp[v][y][x], dp[v][1][x] - dp[v][2 - y][x], dp[v][y][x] - dp[v][2 - y][x]});
          }
          ranges::sort(val, greater());
          ordered_set<pair<int64_t, int>> pickA, pickB;
          for (int i = 0; i < ssize(val); ++i)
            pickA.insert({val[i][2], i});
          auto Get = [](auto &s, int p) -> pair<int64_t, int> {
            if (p == 0) {
              return {numeric_limits<int64_t>::max(), 87};
            } else {
              return *s.find_by_order(s.size() - p);
            }
          };
          int p1 = 0, p2 = 0;
          int64_t tot = 0;
          auto adjust = [&](int need, int k) {
            while (p1 < int(pickA.size())) {
              if (Get(pickA, p1 + 1).first + k > Get(pickB, p2).first) {
                tot += Get(pickA, p1 + 1).first;
                tot -= Get(pickB, p2).first;
                p1 += 1;
                p2 -= 1;
              } else {
                break;
              }
            }
            while (p2 < int(pickB.size())) {
              if (Get(pickB, p2 + 1).first > Get(pickA, p1).first + k) {
                tot += Get(pickB, p2 + 1).first;
                tot -= Get(pickA, p1).first;
                p2 += 1;
                p1 -= 1;
              } else {
                break;
              }
            }
            while (p1 + p2 < need) {
              if (p1 == int(pickA.size())) {
                tot += Get(pickB, p2 + 1).first;
                p2 += 1;
              } else if (p2 == int(pickB.size())) {
                tot += Get(pickA, p1 + 1).first;
                p1 += 1;
              } else if (Get(pickA, p1 + 1).first + k > Get(pickB, p2 + 1).first) {
                tot += Get(pickA, p1 + 1).first;
                p1 += 1;
              } else {
                tot += Get(pickB, p2 + 1).first;
                p2 += 1;
              }
            }
            while (p1 + p2 > need) {
              if (Get(pickA, p1).first + k < Get(pickB, p2).first) {
                tot -= Get(pickA, p1).first;
                p1 -= 1;
              } else {
                tot -= Get(pickB, p2).first;
                p2 -= 1;
              }
            }
          };
          size_t p = 0;
          for (int c = int(val.size()); c >= 0; --c) {
            while (p < val.size() and val[p][0] >= c) {
              pair<int64_t, int> a_key = {val[p][2], p};
              pair<int64_t, int> b_key = {val[p][1], p};
              if (a_key >= Get(pickA, p1)) {
                tot -= a_key.first;
                p1 -= 1;
              }
              if (b_key >= Get(pickB, p2)) {
                tot += b_key.first;
                p2 += 1;
              }
              pickA.erase(a_key);
              pickB.insert(b_key);
              p += 1;
            }
            adjust(int(val.size()) - c, c);
            int64_t cur = sm + tot + p1 * int64_t(c);
            if (c0 == 0) {
              maxi(dp[u][x][1], cur + c * c0);
              maxi(dp[u][x][3], cur + c * c0);
            } else {
              maxi(dp[u][x][y], cur + c * c0);
            }
          }
          c0 += y == 0;
        }
      }
    }
  };
  dfs(dfs, 0, 0);
  cout << max({dp[0][0][3], dp[0][1][3], dp[0][2][3]}) << '\n';
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n;
  cin >> n;
  string s;
  cin >> s;
  for (int i = 1; i < n; ++i) {
    int u, v;
    cin >> u >> v;
    --u, --v;
    g[u].push_back(v);
    g[v].push_back(u);
  }
  if (s.size() == 1) solve1(n);
  else if (s.size() == 2) solve2(n);
  else if (s[0] == s[1] and s[1] == s[2]) {
    solveAAA(n);
  } else if (s[0] == s[1] or s[1] == s[2]) {
    solveAAB(n);
  } else if (s[0] == s[2]) {
    solveABA(n);
  } else {
    solveABC(n);
  }
  return 0;
}