#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>

namespace {
using std::cin;
using std::cout;
using std::int64_t;
using std::size_t;

namespace base {
template <typename T, size_t... sizes>
struct NestedArray {};

template <typename T, size_t size, size_t... sizes>
struct NestedArray<T, size, sizes...> {
  using Type = std::array<typename NestedArray<T, sizes...>::Type, size>;
};

template <typename T>
struct NestedArray<T> {
  using Type = T;
};

template <typename T, size_t... sizes>
using Array = typename NestedArray<T, sizes...>::Type;

void OptimizeIO() {
  std::ios::sync_with_stdio(false);
  cin.tie(nullptr), cout.tie(nullptr);
}

void OptimizeIO(const std::string &input_file, const std::string &output_file) {
  static std::ifstream input_stream(input_file);
  static std::ofstream output_stream(output_file);
  cin.rdbuf(input_stream.rdbuf());
  cout.rdbuf(output_stream.rdbuf());
  cin.tie(nullptr), cout.tie(nullptr);
}
}  // namespace base

using base::Array;

const int kMod = 998244353, kInv2 = (kMod + 1) / 2;

namespace mod {
inline void Add(int &a, int b) {
  a += b;
  if (a >= kMod) a -= kMod;
}

inline void Mul(int &a, int b) { a = static_cast<int64_t>(a) * b % kMod; }

inline int Prod(int a, int b) { return static_cast<int64_t>(a) * b % kMod; }
}  // namespace mod

const int kMaxN = 3.0e5 + 5;
int n, lim, sum;
Array<int, kMaxN> a, p, f;
Array<std::vector<int>, kMaxN> edge;

void Dfs(int u, int fa) {
  f[u] = (a[u] >= lim);

  for (int v : edge[u]) {
    if (v == fa) continue;
    Dfs(v, u);
    mod::Mul(f[u], mod::Prod(f[v] + 1, kInv2));
  }

  mod::Add(sum, f[u]);
}

int Main() {
  base::OptimizeIO();
  cin >> n;
  for (int i = 1; i <= n; i++) cin >> a[i];

  for (int i = 1; i < n; i++) {
    int u, v;
    cin >> u >> v;
    edge[u].emplace_back(v), edge[v].emplace_back(u);
  }

  std::iota(p.begin() + 1, p.begin() + n + 1, 1);
  std::sort(p.begin() + 1, p.begin() + n + 1,
            [](int x, int y) { return a[x] < a[y]; });
  int ans = 0;

  for (int i = 0; i < n; i++) {
    int x = p[i];
    lim = a[x] + 1, sum = 0;
    Dfs(1, 0), mod::Add(sum, f[1]);
    mod::Add(ans, mod::Prod(sum, a[p[i + 1]] - a[x]));
  }

  for (int i = 1; i <= n - 2; i++) mod::Add(ans, ans);
  cout << ans << "\n";
  return 0;
}
}  // namespace

int main() { return Main(); }