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

vector<ll> A, B;
int n, m;

ll cost(ll T) {
    ll res = 0;
    for (ll x : A) if (x < T) res += (T - x);
    for (ll y : B) if (y > T) res += (y - T);
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    freopen("MANG.INP", "r", stdin);
    freopen("MANG.OUT", "w", stdout);

    cin >> n >> m;
    A.resize(n);
    B.resize(m);

    for (int i = 0; i < n; i++) cin >> A[i];
    for (int j = 0; j < m; j++) cin >> B[j];

    ll low = *min_element(A.begin(), A.end());
    ll high = *max_element(B.begin(), B.end());

    if (low >= high) {
        cout << 0;
        return 0;
    }

    // Ternary search (Tìm kiếm 1/3)
    while (high - low > 2) {
        ll mid1 = low + (high - low) / 3;
        ll mid2 = high - (high - low) / 3;
        if (cost(mid1) < cost(mid2))
            high = mid2;
        else
            low = mid1;
    }

    ll ans = 1e18;
    for (ll i = low; i <= high; i++) {
        ans = min(ans, cost(i));
    }
    cout << ans;
    return 0;
}

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    freopen("mang.inp", "r", stdin);
    freopen("mang.out", "w", stdout);

    int n, m;
    cin >> n >> m;

    vector<long long> A(n), B(m);
    for (auto &x : A) cin >> x;
    for (auto &x : B) cin >> x;

    sort(A.begin(), A.end());
    sort(B.begin(), B.end());

    vector<long long> prefA(n + 1), prefB(m + 1);
    for (int i = 1; i <= n; i++) prefA[i] = prefA[i - 1] + A[i - 1];
    for (int i = 1; i <= m; i++) prefB[i] = prefB[i - 1] + B[i - 1];

    vector<long long> candidates;
    for (auto x : A) candidates.push_back(x);
    for (auto x : B) candidates.push_back(x);
    sort(candidates.begin(), candidates.end());
    candidates.erase(unique(candidates.begin(), candidates.end()), candidates.end());

    long long ans = LLONG_MAX;

    for (long long Y : candidates) {
        // Tính chi phí nhanh bằng mảng tiền tố
        long long posA = lower_bound(A.begin(), A.end(), Y) - A.begin();
        long long cntA = n - posA; 
        long long sumA = prefA[n] - prefA[posA];
        long long costA = cntA * Y - sumA;

        long long posB = lower_bound(B.begin(), B.end(), Y) - B.begin();
        long long cntB = posB;
        long long sumB = prefB[posB];
        long long costB = sumB - cntB * Y;

        if (costA + costB < ans) ans = costA + costB;
    }
    cout << ans;
    return 0;
}

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

typedef long long ll;

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    freopen("MANG.INP", "r", stdin);
    freopen("MANG.OUT", "w", stdout);

    int n, m;
    cin >> n >> m;
    vector<ll> a(n), b(m);
    for (auto &x : a) cin >> x;
    for (auto &x : b) cin >> x;

    sort(a.begin(), a.end());
    sort(b.begin(), b.end());

    // Hai con trỏ
    int i = 0;          // Duyệt mảng a (các phần tử nhỏ cần tăng lên)
    int j = m - 1;      // Duyệt mảng b (các phần tử lớn cần giảm xuống)

    ll ans = 0;
    // Logic: Cân bằng lượng tăng và giảm
    // Nếu a[i] < b[j], ta có thể chọn một giá trị Y nằm giữa chúng.
    // Tuy nhiên, bài toán yêu cầu Y phải chung cho tất cả.
    // Phân tích thêm: Hàm chi phí là lồi (convex). 
    // Ta có thể dùng Binary Search hoặc Ternary Search như Approach 1.
    // Code dưới đây là một biến thể của việc tìm Y tối ưu bằng cách duyệt.

    // Tuy nhiên, một cách tiếp cận khác (không thấy trong code mẫu nhưng hợp lý) là:
    // Suy nghĩ lại: Nếu chỉ cần tối thiểu hóa tổng số bước,
    // ta cần tìm Y sao cho số lượng phần tử A[i] < Y và B[j] > Y được cân bằng về mặt chi phí.
    // Thực tế, Y tối ưu nằm giữa max(A) và min(B) nếu chúng giao nhau.
    // Nếu không giao nhau, Y nằm ở điểm giữa.

    // Code minh họa cho Approach 1 (Ternary Search) là chuẩn nhất.
    // Dưới đây là code minh họa cho việc dùng Lower Bound để tìm điểm chuyển dịch của chi phí.

    // Giả định: Y tối ưu nằm trong [min(A), max(B)]
    ll lo = *min_element(a.begin(), a.end());
    ll hi = *max_element(b.begin(), b.end());

    // Nếu tất cả A đều >= B, chi phí là 0
    if (lo >= hi) {
        cout << 0 << endl;
        return 0;
    }

    // Binary Search cho điểm giao của hàm chi phí
    // Hoặc đơn giản là tìm Y sao cho tổng A[i] < Y gần bằng tổng B[j] > Y
    // Code này thực chất là tìm Y sao cho 'lợi nhuận' cân bằng.

    // Tuy nhiên, do hàm chi phí là lồi, Ternary Search là cách dễ nhất để hiện thực.
    // Dưới đây là code sử dụng Binary Search trên Gradient (Đạo hàm).
    // Chi phí tăng thêm khi Y tăng từ T lên T+1 là: 
    //  (số phần tử A[i] <= T) - (số phần tử B[j] > T)
    // Ta cần tìm điểm mà giá trị này gần 0 nhất.

    while (lo < hi) {
        ll mid = lo + (hi - lo) / 2;
        // Đếm số lượng A[i] <= mid
        ll countA = upper_bound(a.begin(), a.end(), mid) - a.begin();
        // Đếm số lượng B[j] > mid
        ll countB = b.end() - upper_bound(b.begin(), b.end(), mid);

        if (countA > countB) {
            // Có quá nhiều A cần tăng, chi phí tăng thêm khi Y tăng là dương (cần giảm Y)
            hi = mid;
        } else {
            // Có quá nhiều B cần giảm, chi phí tăng thêm khi Y tăng là âm (cần tăng Y)
            lo = mid + 1;
        }
    }

    // Tính chi phí tại lo
    ll cost = 0;
    for (ll x : a) if (x < lo) cost += (lo - x);
    for (ll x : b) if (x > lo) cost += (x - lo);
    cout << cost << endl;
    return 0;
}