#include <bits/stdc++.h>
using namespace std;

int main() {
  int N;
  cin >> N;
  long long int S = 0;
  vector<long long int> V(2 * N);
  for (int i = 0; i < 2 * N; i++) {
    cin >> V.at(i);
    S += V.at(i);
  }
  priority_queue<long long int, vector<long long int>, greater<long long int>> Q;
  long long int T = 0;
  for (int i = 0; i < N; i++) {
    Q.push(V.at(N - 1 - i));
    Q.push(V.at(N + i));
    T += Q.top();
    Q.pop();
  }
  cout << S - T << endl;
}
#include <bits/stdc++.h>

using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
using i128 = __int128_t;
using u128 = __uint128_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;

class rep {
    struct Iter {
        usize itr;
        constexpr Iter(const usize pos) noexcept : itr(pos) {}
        constexpr void operator++() noexcept { ++itr; }
        constexpr bool operator!=(const Iter& other) const noexcept {
            return itr != other.itr;
        }
        constexpr usize operator*() const noexcept { return itr; }
    };
    const Iter first, last;

  public:
    explicit constexpr rep(const usize first, const usize last) noexcept
        : first(first), last(std::max(first, last)) {}
    constexpr Iter begin() const noexcept { return first; }
    constexpr Iter end() const noexcept { return last; }
};

template <class T> using Vec = std::vector<T>;

template <class T> using Heap = std::priority_queue<T, Vec<T>, std::greater<T>>;

void B_main() {
    usize N;
    std::cin >> N;
    Vec<u64> V(2 * N);
    for (auto& x : V) {
        std::cin >> x;
    }
    Heap<u64> heap;
    for (const auto i : rep(0, N)) {
        heap.push(V[N - i - 1]);
        heap.push(V[N + i]);
        heap.pop();
    }
    u64 ans = 0;
    while (!heap.empty()) {
        ans += heap.top();
        heap.pop();
    }
    std::cout << ans << '\n';
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    B_main();
    return 0;
}
