#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 <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#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; }
#define COLOR(s) ("\x1b[" s "m")


struct Functional {
  int n;
  vector<int> par;
  int cyclesLen;
  vector<int> lens;
  vector<vector<int>> cycles;
  // cycle id or -1
  vector<int> on;
  // forest
  vector<vector<int>> graph;
  int zeit;
  vector<int> dis, fin, dep;
  // root is cycle[k][l]
  vector<int> ks, ls;
  
  Functional() {}
  Functional(const vector<int> &par_) : par(par_) {
    n = par.size();
    for (int u = 0; u < n; ++u) {
      assert(0 <= par[u]); assert(par[u] < n);
    }
    cycles.clear();
    vector<int> vis(n, -1);
    for (int s = 0; s < n; ++s) {
      int u = s;
      for (; !~vis[u]; u = par[u]) {
        vis[u] = s;
      }
      if (vis[u] == s) {
        vector<int> cycle;
        for (int v = u; ; ) {
          cycle.push_back(v);
          if ((v = par[v]) == u) break;
        }
        cycles.push_back(cycle);
      }
    }
    cyclesLen = cycles.size();
    lens.resize(cyclesLen);
    on.assign(n, -1);
    for (int k = 0; k < cyclesLen; ++k) {
      lens[k] = cycles[k].size();
      for (const int u : cycles[k]) {
        on[u] = k;
      }
    }
    graph.assign(n, {});
    for (int u = 0; u < n; ++u) if (!~on[u]) {
      graph[par[u]].push_back(u);
    }
    zeit = 0;
    dis.assign(n, -1);
    fin.assign(n, -1);
    dep.assign(n, 0);
    ks.assign(n, -1);
    ls.assign(n, -1);
    for (int k = 0; k < cyclesLen; ++k) {
      for (int l = 0; l < lens[k]; ++l) {
        dfs(k, l, cycles[k][l]);
      }
    }
  }
  void dfs(int k, int l, int u) {
    dis[u] = zeit++;
    ks[u] = k;
    ls[u] = l;
    for (const int v : graph[u]) {
      dep[v] = dep[u] + 1;
      dfs(k, l, v);
    }
    fin[u] = zeit;
  }
  
  // min d s.t. f^d(u) = v, or -1
  int dist(int u, int v) const {
    if (ks[u] != ks[v]) return -1;
    if (~on[v]) {
      int dl = ls[v] - ls[u];
      if (dl < 0) dl += lens[ks[u]];
      return dep[u] + dl;
    }
    return (dis[v] <= dis[u] && dis[u] < fin[v]) ? (dep[u] - dep[v]) : -1;
  };
};

////////////////////////////////////////////////////////////////////////////////


constexpr Int INF = 1001001001001001001LL;

int N;
Int W;
vector<int> A, P;

vector<int> ans;

Functional F;

// cycle[l] on time l
struct Waf {
  // on cycle
  int L;
  vector<int> ls;
  // on tree
  vector<int> stack;
  void init(int L_) {
    L = L_;
    ls.clear();
    stack.clear();
  }
  // w ko from time L
  Int get(Int w) const {
    if (ls.size()) {
      const Int quo = (w - 1) / ls.size();
      const Int rem = (w - 1) % ls.size();
      return (1 + quo) * L + ls[rem];
    } else {
      return INF;
    }
  }
  Int add(Int t) {
    stack.push_back(t);
    if (W < (int)stack.size()) {
      return stack.end()[-W];
    } else {
      return get(W - (int)stack.size());
    }
  }
  void undo() {
    stack.pop_back();
  }
};
vector<Waf> waf;

void dfs(int u, int t, pair<Int, int> near) {
  const Int res = waf[A[u]].add(t);
  chmin(near, make_pair(res, A[u]));
cerr<<"[dfs] u = "<<u<<", t = "<<t<<", near = "<<near<<endl;
  ans[u] = near.second;
  for (const int v : F.graph[u]) {
    dfs(v, t - 1, near);
  }
  waf[A[u]].undo();
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d%lld", &N, &W);
    A.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%d", &A[u]);
      --A[u];
    }
    P.resize(N);
    for (int u = 0; u < N; ++u) {
      scanf("%d", &P[u]);
      --P[u];
    }
    
    ans.assign(N, -1);
    
    F = Functional(P);
    const int K = F.cycles.size();
    vector<vector<int>> uss(K);
    for (int u = 0; u < N; ++u) uss[F.ks[u]].push_back(u);
    waf.resize(N);
    for (int k = 0; k < K; ++k) {
      const auto &C = F.cycles[k];
      const int L = C.size();
      for (const int u : uss[k]) waf[A[u]].init(L);
      for (int l = 0; l < L; ++l) waf[A[C[l]]].ls.push_back(l);
      pair<Int, int> near(INF, -1);
      for (int l = 0; l < L; ++l) {
        const Int res = waf[A[C[l]]].get(W);
        chmin(near, make_pair(res, A[C[l]]));
      }
// cerr<<"C = "<<C<<", near = "<<near<<endl;
      for (int l = L; --l >= 0; ) {
        dfs(C[l], l, near);
        const Int res = waf[A[C[l]]].add(l);
        chmin(near, make_pair(res, A[C[l]]));
      }
    }
// cerr<<"ans = "<<ans<<endl;
    
    Int key = 0;
    for (int u = 0; u < N; ++u) key += (u + 1) * (ans[u] + 1);
    printf("%lld\n", key);
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}