#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


int N, M;
vector<int> C;
vector<int> A, B;

vector<vector<int>> G, H;

int zeit;
vector<int> dis, low, sz;

void dfsLow(int u, int pi) {
  dis[u] = low[u] = zeit++;
  sz[u] = 1;
  for (const int i : G[u]) if (pi != i) {
    const int v = A[i] ^ B[i] ^ u;
    if (~dis[v]) {
      chmin(low[u], dis[v]);
    } else {
      H[u].push_back(i);
      dfsLow(v, i);
      sz[u] += sz[v];
      chmin(low[u], low[v]);
    }
  }
}

int ZEIT;
vector<int> DIS, FIN;
vector<int> US;

void dfsHLD(int u) {
  DIS[u] = ZEIT++;
  US.push_back(u);
  const int deg = H[u].size();
  if (deg > 0) {
    const int i0 = H[u][0];
    int vm = A[i0] ^ B[i0] ^ u;
    int jm = 0;
    for (int j = 1; j < deg; ++j) {
      const int i = H[u][j];
      const int v = A[i] ^ B[i] ^ u;
      if (sz[vm] < sz[v]) {
        vm = v;
        jm = j;
      }
    }
    swap(H[u][0], H[u][jm]);
    for (int j = 0; j < deg; ++j) {
      const int i = H[u][j];
      const int v = A[i] ^ B[i] ^ u;
      dfsHLD(v);
    }
  }
  FIN[u] = ZEIT;
}

struct Solver {
  int mx;
  vector<int> fs, gs;
  Solver() {}
  Solver(int fsLen, int gsLen) : mx(0), fs(fsLen, 0), gs(gsLen, 0) {
    gs[0] = fsLen;
  }
  void add(int c) {
    --gs[fs[c]];
    ++fs[c];
    ++gs[fs[c]];
    chmax(mx, fs[c]);
  }
  void rem(int c) {
    --gs[fs[c]];
    --fs[c];
    ++gs[fs[c]];
    if (!gs[mx]) --mx;
  }
};
Solver inside, outside;

void add(int u) {
// cerr<<"  add u="<<u<<endl;
  inside.add(C[u]);
  outside.rem(C[u]);
}
void rem(int u) {
// cerr<<"  rem u="<<u<<endl;
  inside.rem(C[u]);
  outside.add(C[u]);
}

// process all edges below u
// after calling, all vertexes below= u are added
vector<int> ans;
void solve(int u) {
// cerr<<"solve "<<u<<endl;
  const int deg = H[u].size();
  if (deg > 0) {
    for (int j = deg; --j >= 0; ) {
      const int i = H[u][j];
      const int v = A[i] ^ B[i] ^ u;
      solve(v);
// cerr<<"  ans["<<i<<"] "<<inside.mx<<" + "<<outside.mx<<endl;
      if (dis[v] == low[v]) {
        ans[i] = inside.mx + outside.mx;
      }
      if (j) {
        for (int h = DIS[v]; h < FIN[v]; ++h) rem(US[h]);
      }
    }
    for (int j = deg; --j >= 1; ) {
      const int i = H[u][j];
      const int v = A[i] ^ B[i] ^ u;
      for (int h = DIS[v]; h < FIN[v]; ++h) add(US[h]);
    }
  }
  add(u);
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d%d", &N, &M);
    C.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%d", &C[u]);
    }
    A.resize(M);
    B.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    
    auto cs = C;
    sort(cs.begin(), cs.end());
    cs.erase(unique(cs.begin(), cs.end()), cs.end());
    const int csLen = cs.size();
    for (int u = 0; u < N; ++u) {
      C[u] = lower_bound(cs.begin(), cs.end(), C[u]) - cs.begin();
    }
// cerr<<"C = "<<C<<endl;
    inside = Solver(csLen, N + 1);
    outside = Solver(csLen, N + 1);
    
    G.assign(N, {});
    H.assign(N, {});
    for (int i = 0; i < M; ++i) {
      G[A[i]].push_back(i);
      G[B[i]].push_back(i);
    }
    zeit = 0;
    dis.assign(N, -1);
    low.assign(N, -1);
    sz.assign(N, -1);
    ZEIT = 0;
    DIS.assign(N, -1);
    FIN.assign(N, -1);
    US.clear();
    
    int sumOrig = 0;
    ans.assign(M, 0);
    for (int r = 0; r < N; ++r) if (!~dis[r]) {
      dfsLow(r, -1);
      dfsHLD(r);
// cerr<<"DO ";pv(US.begin()+DIS[r],US.begin()+FIN[r]);
      for (int h = DIS[r]; h < FIN[r]; ++h) {
        const int u = US[h];
// cerr<<"  outside.add u="<<u<<endl;
        outside.add(C[u]);
      }
      solve(r);
      const int orig = inside.mx;
// cerr<<"  orig = "<<orig<<endl;
      sumOrig += orig;
      for (int h = DIS[r]; h < FIN[r]; ++h) {
        const int u = US[h];
// cerr<<"  inside.rem u="<<u<<endl;
        inside.rem(C[u]);
        for (const int i : H[u]) {
          const int v = A[i] ^ B[i] ^ u;
          if (dis[v] == low[v]) {
            ans[i] -= orig;
          }
        }
      }
    }
// cerr<<"H = "<<H<<endl;
// cerr<<"DIS = "<<DIS<<endl;
// cerr<<"FIN = "<<FIN<<endl;
// cerr<<"US = "<<US<<endl;
    for (int i = 0; i < M; ++i) {
      ans[i] += sumOrig;
    }
    
    for (int i = 0; i < M; ++i) {
      if (i) printf(" ");
      printf("%d", ans[i]);
    }
    puts("");
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}