// ---------- begin chmin, chmax ----------
pub trait ChangeMinMax {
    fn chmin(&mut self, x: Self) -> bool;
    fn chmax(&mut self, x: Self) -> bool;
}

impl<T: PartialOrd> ChangeMinMax for T {
    fn chmin(&mut self, x: Self) -> bool {
        *self > x && {
            *self = x;
            true
        }
    }
    fn chmax(&mut self, x: Self) -> bool {
        *self < x && {
            *self = x;
            true
        }
    }
}
// ---------- end chmin, chmax ----------
// ---------- begin Li Chao Tree ----------
// verify: https://old.yosupo.jp/submission/66738
#[derive(Clone)]
pub struct Line {
    a: i64,
    b: i64,
}

impl Line {
    pub fn new(a: i64, b: i64) -> Self {
        Line { a, b }
    }
    pub fn eval(&self, x: i64) -> i64 {
        self.a * x + self.b
    }
}

pub struct LiChaoTree(Vec<(i64, Line)>);

impl LiChaoTree {
    fn inorder(&mut self, v: usize, point: &[i64], x: &mut usize) {
        if v >= self.0.len() {
            return;
        }
        self.inorder(2 * v + 1, point, x);
        self.0[v].0 = point[*x];
        *x += 1;
        self.inorder(2 * v + 2, point, x);
    }
    pub fn new(mut point: Vec<i64>) -> Self {
        assert!(point.len() > 0);
        point.sort();
        point.dedup();
        let mut cht = Self(vec![(0, Line::new(0, std::i64::MAX)); point.len()]);
        cht.inorder(0, &point, &mut 0);
        cht
    }
    pub fn insert(&mut self, mut line: Line) {
        let mut v = 0;
        while let Some(p) = self.0.get_mut(v) {
            if p.1.eval(p.0) > line.eval(p.0) {
                std::mem::swap(&mut p.1, &mut line);
            }
            v = 2 * v + if line.a > p.1.a { 1 } else { 2 };
        }
    }
    pub fn find(&self, x: i64) -> i64 {
        let mut res = std::i64::MAX;
        let mut v = 0;
        while let Some(p) = self.0.get(v) {
            res = res.min(p.1.eval(x));
            v = 2 * v + if x < p.0 { 1 } else { 2 }
        }
        res
    }
}
// ---------- end Li Chao Tree ----------
// ---------- begin scannner ----------
#[allow(dead_code)]
mod scanner {
    use std::str::FromStr;
    pub struct Scanner<'a> {
        it: std::str::SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a String) -> Scanner<'a> {
            Scanner {
                it: s.split_whitespace(),
            }
        }
        pub fn next<T: FromStr>(&mut self) -> T {
            self.it.next().unwrap().parse::<T>().ok().unwrap()
        }
        pub fn next_bytes(&mut self) -> Vec<u8> {
            self.it.next().unwrap().bytes().collect()
        }
        pub fn next_chars(&mut self) -> Vec<char> {
            self.it.next().unwrap().chars().collect()
        }
        pub fn next_vec<T: FromStr>(&mut self, len: usize) -> Vec<T> {
            (0..len).map(|_| self.next()).collect()
        }
    }
}
// ---------- end scannner ----------

use std::io::Write;
use std::collections::*;

type Map<K, V> = BTreeMap<K, V>;
type Set<T> = BTreeSet<T>;
type Deque<T> = VecDeque<T>;

fn main() {
    use std::io::Read;
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut sc = scanner::Scanner::new(&s);
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    run(&mut sc, &mut out);
}

fn run<W: Write>(sc: &mut scanner::Scanner, out: &mut std::io::BufWriter<W>) {
    let t: u32 = sc.next();
    for _ in 0..t {
        let n: usize = sc.next();
        let k: usize = sc.next();
        let x: Vec<i64> = sc.next_vec::<i64>(n);
        let s: Vec<i64> = sc.next_vec::<i64>(n);
        let ans = solve(k, x, s);
        writeln!(out, "{}", ans).ok();
    }
}

fn solve(k: usize, x: Vec<i64>, s: Vec<i64>) -> i64 {
    let n = x.len();
    let mut ord = (0..n).collect::<Vec<_>>();
    ord.sort_by_key(|p| x[*p]);
    let e = ord.iter().map(|e| (x[*e], s[*e])).collect::<Vec<_>>();
    let src = ord.iter().position(|x| *x == 0).unwrap();
    let dst = ord.iter().position(|x| *x == n - 1).unwrap();
    let mut ans = std::i64::MAX;
    for i in 0..2 {
        let inf = std::i64::MAX / 2;
        let mut dp = vec![inf; n];
        dp[src] = 0;
        let point = e.iter().map(|e| e.0).collect::<Vec<_>>();
        for j in 0..=k {
            let mut cht = LiChaoTree::new(point.clone());
            let mut update = false;
            if (i + j) % 2 == 0 {
                for (i, &(x, s)) in e.iter().enumerate() {
                    let val = cht.find(x);
                    update |= dp[i].chmin(val);
                    if dp[i] != inf {
                        cht.insert(Line::new(s, dp[i] - s * x));
                    }
                }
            } else {
                for (i, &(x, s)) in e.iter().enumerate().rev() {
                    let val = cht.find(-x);
                    update |= dp[i].chmin(val);
                    if dp[i] != inf {
                        cht.insert(Line::new(s, dp[i] + s * x));
                    }
                }
            }
            if !update {
                break;
            }
        }
        ans = ans.min(dp[dst]);
    }
    ans
}