#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 = 100100;

vector<pair<int, int>> G[MAXN];
int tin[MAXN];
int tup[MAXN];
int ttime = 0;
int col[MAXN];
bool is_bridge[MAXN];

void dfs1(int v, int p) {
  tin[v] = ttime;
  tup[v] = ttime;
  ++ttime;
  for (auto [u, i] : G[v]) {
    if (i == p)
      continue;
    if (tin[u] == -1) {
      dfs1(u, i);
      tup[v] = min(tup[v], tup[u]);
      if (tup[u] > tin[v]) {
        is_bridge[i] = true;
      }
    } else {
      tup[v] = min(tup[v], tin[u]);
    }
  }
}

void dfs2(int v, int c) {
  col[v] = c;
  for (auto [u, i] : G[v]) {
    if (is_bridge[i])
      continue;
    if (col[u] == -1) {
      dfs2(u, c);
    }
  }
}

vector<int> vals[MAXN];
int sz[MAXN];


struct Something {
  int id[MAXN];
  vector<int> start_values;
  vector<int> real_values;
  int cur_mx;
  int i;
  int int_cnt;
  int start_int_cnt;

  void setup(vector<pair<int, int>> vals) {
    real_values.resize(vals.size());
    for (int i = 0; i < vals.size(); ++i) {
      id[vals[i].second] = i;
      real_values[i] = vals[i].first;
    }
    start_values = real_values;
    cur_mx = real_values[0];
    start_int_cnt = 1;
    while (start_int_cnt < start_values.size() && start_values[start_int_cnt] >= cur_mx)
      ++start_int_cnt;
    int_cnt = start_int_cnt;
    i = 0;
  }
  void erase(int x) {
    --real_values[id[x]];
    while (true) {
      while (i < int_cnt && real_values[i] < cur_mx)
        ++i;
      if (i < int_cnt)
        break;
      --cur_mx;
      while (int_cnt < start_values.size() && start_values[int_cnt] >= cur_mx)
        ++int_cnt;
      i = 0;
    }
  }
  void insert(int x) {
    ++real_values[id[x]];
  } // all inserts are after all erase and then a rebuild
  void rebuild() {
    cur_mx = start_values[0];
    int_cnt = start_int_cnt;
    i = 0;
  }
  int get_mx() {
    return cur_mx;
  }
};

struct SomethingDumb {
  int cnt[MAXN];
  int mx_id = 0;

  void insert(int x) {
    ++cnt[x];
    if (cnt[x] > cnt[mx_id])
      mx_id = x;
  }
  void erase(int x) {
    --cnt[x];
  }
  int get_mx() {
    return cnt[mx_id];
  }
};

const int K = 18;
Something lefts[K];
SomethingDumb rights[K];
vector<int> vertices[K];

void move(Something& from, SomethingDumb& to, int x) {
  from.erase(x);
  to.insert(x);
}

void move(SomethingDumb& from, Something& to, int x) {
  from.erase(x);
  to.insert(x);
}

vector<int> comp;

void dfs_sz(int v, int p) {
  comp.emplace_back(v);
  sz[v] = 1;
  for (int j = 0; j < G[v].size(); ++j) {
    auto [u, i] = G[v][j];
    if (i == p) {
      swap(G[v][j], G[v].back());
      G[v].pop_back();
      --j;
      continue;
    }
    dfs_sz(u, i);
    sz[v] += sz[u];
    if (sz[u] > sz[G[v][0].first])
      swap(G[v][0], G[v][j]);
  }
}

void dfs_dp(int v, int w, int p, vector<int>& ans, int cur) {
  if (!G[v].empty()) {
    dfs_dp(G[v][0].first, w, G[v][0].second, ans, cur);
    for (int j = 1; j < G[v].size(); ++j) {
      auto [u, i] = G[v][j];
      dfs_dp(u, w + 1, i, ans, cur);
      for (int t : vertices[w + 1]) {
        vertices[w].emplace_back(t);
        for (int y : vals[t]) {
          move(rights[w + 1], lefts[w + 1], y);
          move(lefts[w], rights[w], y);
        }
      }
      lefts[w + 1].rebuild();
      vertices[w + 1].clear();
    }
  }
  for (int x : vals[v]) {
    move(lefts[w], rights[w], x);
  }
  vertices[w].emplace_back(v);
  if (p != -1) {
    ans[p] += lefts[w].get_mx() + rights[w].get_mx() - cur;
  }
}

//#define STRESS

vector<int> solve(vector<int> A, vector<pair<int, int>> edges) {
  int n = A.size();
  int m = edges.size();
  for (int i = 0; i < m; ++i) {
    auto [a, b] = edges[i];
    G[a].emplace_back(b, i);
    G[b].emplace_back(a, i);
  }
  ttime = 0;
  fill(tin, tin + n, -1);
  fill(is_bridge, is_bridge + m, false);
  for (int i = 0; i < n; ++i) {
    if (tin[i] == -1) {
      dfs1(i, -1);
    }
  }
  int comp_cnt = 0;
  fill(col, col + n, -1);
  for (int i = 0; i < n; ++i) {
    if (col[i] == -1) {
      dfs2(i, comp_cnt);
      ++comp_cnt;
    }
  }
  for (int i = 0; i < n; ++i)
    G[i].clear();
  for (int i = 0; i < n; ++i)
    vals[col[i]].emplace_back(A[i]);

  vector<int> ans(m);
  for (int i = 0; i < m; ++i) {
    if (is_bridge[i]) {
      auto [u, v] = edges[i];
      u = col[u];
      v = col[v];
      G[u].emplace_back(v, i);
      G[v].emplace_back(u, i);
    }
  }
  int total_add = 0;
  fill(sz, sz + n, 0);
  for (int i = 0; i < comp_cnt; ++i) {
    if (sz[i] != 0)
      continue;
    dfs_sz(i, -1);
    map<int, int> cnt;
    for (int v : comp) {
      for (int x : vals[v])
        ++cnt[x];
    }
    vector<pair<int, int>> vvals;
    for (auto [x, c] : cnt)
      vvals.emplace_back(c, x);
    sort(vvals.rbegin(), vvals.rend());
    for (int j = 0; j < K; ++j) {
      lefts[j].setup(vvals);
    }

    int cur = lefts[0].get_mx();
    total_add += cur;
    dfs_dp(i, 0, -1, ans, cur);
    vertices[0].clear();

    for (int v : comp) {
      for (int x : vals[v]) {
        rights[0].erase(x);
      }
    }
    comp.clear();
  }

  for (int i = 0; i < comp_cnt; ++i)
    vals[i].clear();
  for (int i = 0; i < comp_cnt; ++i)
    G[i].clear();
  for (int i = 0; i < m; ++i)
    ans[i] += total_add;
  return ans;
}

vector<int> solve_dumb(vector<int> A, vector<pair<int, int>> edges) {
  int n = A.size();
  int m = edges.size();
  vector<int> ans;
  for (int without = 0; without < m; ++without) {
    vector<vector<int>> G(n);
    for (int i = 0; i < m; ++i) {
      if (i == without)
        continue;
      auto [a, b] = edges[i];
      G[a].emplace_back(b);
      G[b].emplace_back(a);
    }
    int res = 0;
    vector<bool> was(n, false);
    for (int i = 0; i < n; ++i) {
      if (was[i])
        continue;
      vector<int> Q;
      Q.emplace_back(i);
      was[i] = true;
      int q_st = 0;
      while (q_st < Q.size()) {
        int v = Q[q_st];
        ++q_st;
        for (int u : G[v]) {
          if (!was[u]) {
            was[u] = true;
            Q.emplace_back(u);
          }
        }
      }
      map<int, int> cnt;
      for (int v : Q)
        ++cnt[A[v]];
      int mx = 0;
      for (auto [x, c] : cnt)
        mx = max(mx, c);
      res += mx;
    }
    ans.emplace_back(res);
  }
  return ans;
}

//#define STRESS

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  
#ifdef STRESS
  for (int t = 0; t < 100100; ++t) {
    int n = rand() % 5 + 1;
    int m = rand() % 7 + 1;
    vector<int> A(n);
    for (int i = 0; i < n; ++i)
      A[i] = rand() % n;
    vector<pair<int, int>> edges(m);
    for (int i = 0; i < m; ++i) {
      edges[i] = make_pair(rand() % n, rand() % n);
    }
    auto ans1 = solve(A, edges);
    auto ans2 = solve_dumb(A, edges);
    if (ans1 != ans2) {
      cerr << "BUG!!!\n";
      cerr << n << ' ' << m << '\n';
      for (int i = 0; i < n; ++i)
        cerr << A[i] << ' ';
      cerr << '\n';
      for (int i = 0; i < m; ++i) {
        cerr << edges[i].first + 1 << ' ' << edges[i].second + 1 << '\n';
      }
      cerr << "wrong: ";
      for (int x : ans1)
        cerr << x << ' ';
      cerr << "\nright: ";
      for (int x : ans2)
        cerr << x << ' ';
      cerr << "\n\n\n";
    }
  }
#else
  int t;
  cin >> t;
  while (t--) {
    int n, m;
    cin >> n >> m;
    vector<int> A(n);
    for (int i = 0; i < n; ++i)
      cin >> A[i];
    vector<pair<int, int>> edges(m);
    for (int i = 0; i < m; ++i) {
      int a, b;
      cin >> a >> b;
      --a;
      --b;
      edges[i] = make_pair(a, b);
    }
    auto ans = solve(A, edges);
    for (int i = 0; i < m; ++i)
      cout << ans[i] << (i + 1 == m ? '\n' : ' ');
  }
#endif
  return 0;
}