#include <bits/stdc++.h>
const int INF = 0x3F3F3F3F;
struct buf {
  operator int() {
    register int c = getchar(), x = 0;
    for (; !isdigit(c); c = getchar())
      ;
    for (; isdigit(c); c = getchar()) x = x * 10 - '0' + c;
    return x;
  }
} fio;
int a[500000 + 1][2];
inline int cmp(int i, int j, int k) { return a[i][k] < a[j][k] ? i : j; }
struct res {
  int i, j;
  bool operator<(const res& r) const {
    return a[i][0] + a[j][1] < a[r.i][0] + a[r.j][1];
  }
} res_nil, r;
struct dat {
  int v, i, j, k, l;
  res r, s, t;
  dat() {}
  dat(int p, int v = 0)
      : v(v), i(p), j(p), k(p), l(0), r((res){p, p}), s(r), t(s) {}
  dat operator+(const dat& p) const {
    static dat q;
    q.v = std::min(v, p.v);
    q.i = cmp(i, p.i, 0), q.j = cmp(j, p.j, 1);
    q.k = v == q.v ? k : cmp(i, p.k, 0);
    q.l = p.v == q.v ? p.l : cmp(p.j, l, 1);
    q.r = std::min((res){i, p.j}, std::min(r, p.r));
    q.s = std::min((res){p.i, j}, std::min(s, p.s));
    q.t = std::min((res){p.v == q.v ? p.k : p.i, v == q.v ? l : j},
                   std::min(v == q.v ? t : s, p.v == q.v ? p.t : p.s));
    return q;
  }
};
struct seg {
  int l, m, r, d;
  dat x;
  seg *pl, *pr;
} seg_mem[500000 * 2], *seg_cur = seg_mem, *seg_res;
inline void seg_upd(seg* p) { p->x = p->pl->x + p->pr->x; }
inline seg* seg_new(int i) {
  return *seg_cur = (seg){i, 0, i + 1, 0, dat(i), NULL, NULL}, seg_cur++;
}
inline seg* seg_new(int l, int m, int r, seg* pl, seg* pr) {
  return *seg_cur = (seg){l, m, r, 0, pl->x + pr->x, pl, pr}, seg_cur++;
}
inline seg* seg_ini(int l, int r) {
  int m = l + ((r - l) >> 1);
  return l + 1 < r ? seg_new(l, m, r, seg_ini(l, m), seg_ini(m, r))
                   : seg_new(l);
}
inline void seg_add(seg* p, int d) { p->d += d, p->x.v += d; }
inline void seg_dwn(seg* p) {
  if (p->d) seg_add(p->pl, p->d), seg_add(p->pr, p->d), p->d = 0;
}
inline void seg_add(seg* p, int l, int r, int d) {
  if (l == p->l && r == p->r)
    seg_add(p, d);
  else if (r <= p->m)
    seg_dwn(p), seg_add(p->pl, l, r, d), seg_upd(p);
  else if (l >= p->m)
    seg_dwn(p), seg_add(p->pr, l, r, d), seg_upd(p);
  else
    seg_dwn(p), seg_add(p->pl, l, p->m, d), seg_add(p->pr, p->m, r, d),
        seg_upd(p);
}
inline void seg_mdf(seg* p, int i, int o) {
  if (!p->pl)
    a[i][o] = INF, p->x = dat(i, p->x.v);
  else
    seg_dwn(p), seg_mdf(i < p->m ? p->pl : p->pr, i, o), seg_upd(p);
}
int n, m, i, j;
long long ans;
int main() {
  n = fio, m = fio;
  a[0][0] = a[0][1] = INF;
  for (i = 1; i <= n; ++i) a[i][0] = fio;
  for (i = 1; i <= n; ++i) a[i][1] = fio;
  seg_res = seg_ini(1, n + 1);
  while (m--) {
    r = std::min(seg_res->x.r, seg_res->x.v ? seg_res->x.s : seg_res->x.t);
    ans += a[i = r.i][0] + a[j = r.j][1];
    seg_mdf(seg_res, i, 0);
    seg_mdf(seg_res, j, 1);
    if (i < j) seg_add(seg_res, i, j, +1);
    if (i > j) seg_add(seg_res, j, i, -1);
  }
  printf(
      "%lld"
      "\n",
      ans);
  return 0;
}
