#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ld = long double;
using ull = unsigned long long;

bool chmin(auto &a, auto b) {
    if(a <= b) return false;
    a = b;
    return true;
}

bool chmax(auto &a, auto b) {
    if(a >= b) return false;
    a = b;
    return true;
}

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<ll> x(n), s(n);
    rep(i,0,n) std::cin >> x[i];
    rep(i,0,n) std::cin >> s[i];
    s[n-1] = 0;
    std::vector<int> ids(n);
    std::iota(all(ids), 0);
    std::sort(all(ids), [&](int i, int j) -> bool {
        return x[i] < x[j];
    });
    int id0 = -1;
    rep(i,0,n) {
        if(ids[i] == 0) {
            id0 = i;
            break;
        }
    }
    assert(id0 != -1);
    std::vector<int> left, right;
    left.emplace_back(0);
    right.emplace_back(0);
    rrep(i,0,id0) {
        if(s[left.back()] > s[ids[i]]) {
            left.emplace_back(ids[i]);
        }
    }
    rep(i,id0+1,n) {
        if(s[right.back()] > s[ids[i]]) {
            right.emplace_back(ids[i]);
        }
    }
    ll ans = std::abs(x[0] - x[n-1]) * s[0];
    int sl = left.size(), sr = right.size();
    std::vector<int> nl(sl), nr(sr);
    rep(i,0,sl) {
        nl[i] = std::upper_bound(all(right), left[i], [&](int a, int b) -> bool {
            return s[a] > s[b];
        }) - right.begin();
    }
    rep(i,0,sr) {
        nr[i] = std::upper_bound(all(left), right[i], [&](int a, int b) -> bool {
            return s[a] > s[b];
        }) - left.begin();
    }
    const ll INF = std::numeric_limits<ll>::max() / 4;
    std::vector<ll> dpl(sl, INF), dpr(sr, INF);
    dpl[0] = 0;
    dpr[0] = 0;
    // chmin(k, 120);
    while(k--) {
        auto nxtl = dpl;
        auto nxtr = dpr;
        rep(i,0,sl) {
            if(i < sl - 1) {
                chmin(dpl[i+1], dpl[i] + s[left[i]] * std::abs(x[left[i]] - x[left[i+1]]));
            }
            if(nl[i] < sr) {
                chmin(nxtr[nl[i]], dpl[i] + s[left[i]] * std::abs(x[left[i]] - x[right[nl[i]]]));
            }
        }
        rep(i,0,sr) {
            if(i < sr - 1) {
                chmin(dpr[i+1], dpr[i] + s[right[i]] * std::abs(x[right[i]] - x[right[i+1]]));
            }
            if(nr[i] < sl) {
                chmin(nxtl[nr[i]], dpr[i] + s[right[i]] * std::abs(x[right[i]] - x[left[nr[i]]]));
            }
        }
        if(left.back() == n-1) {
            chmin(ans, dpl.back());
        }
        else if(right.back() == n-1) {
            chmin(ans, dpr.back());
        }
        else assert(0);
        std::swap(dpl, nxtl);
        std::swap(dpr, nxtr);
    }
    std::cout << ans << '\n';
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }
}