#include <bits/stdc++.h>

using namespace std;
const int N=2e5+11,inf=0x3f3f3f3f;

int n,k,t[N],a[N],v[N];

vector<int> r[N];
deque<int> loop[N];
int lTail;
vector<int> posOnPath[N];
deque<int> posOnLoop[N];

bool onLoop[N];

struct M{
    int pathDep;
    int cntPath;
    int cntLoop;
    int type;
    bool operator <(const M &m)const{
        if(pathDep!=m.pathDep)return pathDep<m.pathDep;
        if(cntLoop==0)return false;
        if(m.cntLoop==0)return true;
        int cr=(k-cntPath-1)/cntLoop,mcr=(k-m.cntPath-1)/m.cntLoop;
        if(cr!=mcr)return cr<mcr;
        return posOnLoop[type][(k-cntPath)-cr*cntLoop-1]<posOnLoop[m.type][(k-m.cntPath)-mcr*m.cntLoop-1];
    }
    M()=delete;
    M(int pathDep,int cntPath,int cntLoop,int type):pathDep(pathDep),cntPath(cntPath),cntLoop(cntLoop),type(type){}
};


void dfs(int now,int d,vector<M> &mushrooms,M &pathMin){
    posOnPath[t[now]].push_back(d);
    M oldValue=mushrooms[t[now]];
    M oldMin=pathMin;
    if((int)posOnPath[t[now]].size()>=k){
        mushrooms[t[now]].pathDep=posOnPath[t[now]][(int)posOnPath[t[now]].size()-k];    
    }
    mushrooms[t[now]].cntPath=(int)posOnPath[t[now]].size();
    pathMin=min(pathMin,mushrooms[t[now]]);
    v[now]=pathMin.type;
    for(int to:r[now]){
        if(onLoop[to])continue;
        dfs(to,d+1,mushrooms,pathMin);
    }
    mushrooms[t[now]]=oldValue;
    pathMin=oldMin;
    posOnPath[t[now]].pop_back();
}
void work(){
    cin>>n>>k;
    for(int i=0;i<=n;++i){
        r[i].clear();
        loop[i].clear();
        posOnPath[i].clear();
        posOnLoop[i].clear();
        onLoop[i]=false;
        v[i]=0;
    }
    for(int i=1;i<=n;++i)cin>>t[i];
    for(int i=1;i<=n;++i){
        cin>>a[i];
        r[a[i]].push_back(i);
    }

    lTail=0;
    vector<bool> vis(n+1,false),inStack(n+1,false);
    vector<int> stk;
    for(int i=1;i<=n;++i){
        if(!vis[i]){
            int now=i;
            stk.clear();
            while(1){
                inStack[now]=true;
                vis[now]=true;
                stk.push_back(now);
                if(inStack[a[now]]){
                    while(!stk.empty()){
                        loop[lTail].push_front(stk.back());
                        onLoop[stk.back()]=true;
                        if(stk.back()==a[now])break;
                        inStack[stk.back()]=false;
                        stk.pop_back();
                    }
                    lTail+=1;
                    break;
                }
                if(vis[a[now]])break;
                now=a[now];
            }
            while(!stk.empty()){
                inStack[stk.back()]=false;
                stk.pop_back();
            }
        }
    }

    vector<M> mushrooms(n+1,M(inf,0,0,0));
    for(int i=1;i<=n;++i)mushrooms[i].type=i;
    for(int l=0;l<lTail;++l){
        vector<int> usedT;
        M mn=M(inf,0,0,-1);
        for(int u:loop[l]){
            usedT.push_back(t[u]);
            mushrooms[t[u]].cntLoop+=1;
            mn=min(mn,mushrooms[t[u]]);
        }
        for(int i=0;i<(int)loop[l].size();++i){
            posOnLoop[t[loop[l][i]]].push_back(i);
        }
        for(int i=0;i<(int)loop[l].size();++i){
            posOnLoop[t[loop[l][i]]].pop_front();
            posOnLoop[t[loop[l][i]]].push_back(i+(int)loop[l].size());
            
            dfs(loop[l][i],1,mushrooms,mn);
        }
        for(int type:usedT){
            posOnLoop[type].clear();
            mushrooms[type]=M(inf,0,0,type);
        }
    }
    long long ans=0;
    for(int i=1;i<=n;++i){
        //cout<<v[i]<<" ";
        ans+=1ll*i*v[i];
    }
    cout<<ans<<"\n";
}
int main(){
    // ios::sync_with_stdio(0);
    // cin.tie(0);
    int T;
    cin>>T;
    while(T--){
        work();
    }
    return 0;
}