#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main() {
    int N;
    cin >> N;
    // Priority queue lưu trữ độ dài các thanh gỗ tạm thời, lớn nhất ở trên (max-heap)
    // Ban đầu chỉ có 1 thanh gỗ duy nhất là L (tổng độ dài)
    long long total_len = 0;
    vector<long long> A(N);
    for (int i = 0; i < N; i++) {
        cin >> A[i];
        total_len += A[i];
    }

    // Sử dụng max-heap để mô phỏng quá trình ghép ngược (Reverse Huffman)
    // Ban đầu heap chứa các miếng gỗ cuối cùng A[i]
    priority_queue<long long, vector<long long>, greater<long long>> pq; // Min heap simulating Huffman

    // Tuy nhiên, cách tiếp cận Huffman tree là:
    // Luôn chọn 2 đoạn nhỏ nhất để hợp nhất.
    // Chi phí hợp nhất = tổng của chúng.
    // Nếu dùng max-heap để tách (top-down): Chọn thanh lớn nhất để tách.
    // Vấn đề: Tách làm sao cho tối ưu? Cắt đôi? Cắt theo tỉ lệ?

    // Đáp án chính xác cho bài toán này là Huffman Coding Tree.
    // Hãy suy nghĩ ngược lại: Thay vì cắt từ trên xuống, hãy nghĩ đến việc ráp các mảnh lại từ dưới lên.
    // Ban đầu có N mảnh riêng lẻ. Để có 1 mảnh lớn L, ta cần hợp nhất chúng.
    // Chi phí hợp nhất 2 mảnh a, b là a + b.
    // Cần tìm cách hợp nhất để tổng chi phí (a+b) các lần hợp nhất là nhỏ nhất.
    // Đây chính là bài toán xây dựng Huffman Tree.
    // Luôn hợp nhất 2 đoạn ngắn nhất.

    priority_queue<long long, vector<long long>, greater<long long>> minHeap;
    for (long long x : A) {
        minHeap.push(x);
    }

    long long total_cost = 0;
    // Nếu chỉ có 1 mảnh, chi phí là 0 (không cần cắt)
    while (minHeap.size() > 1) {
        long long first = minHeap.top(); minHeap.pop();
        long long second = minHeap.top(); minHeap.pop();
        long long combined = first + second;
        total_cost += combined;
        minHeap.push(combined);
    }

    cout << total_cost << endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

int main() {
    int N;
    cin >> N;
    vector<long long> A(N);
    long long sum = 0;
    for(int i=0; i<N; ++i) {
        cin >> A[i];
    }

    // Sắp xếp mảng tăng dần
    sort(A.begin(), A.end());

    long long total_cost = 0;

    // Sử dụng một hàng đợi ưu tiên phụ hoặc chỉ đơn giản là xử lý mảng
    // Tuy nhiên, để xử lý hiệu quả các số lớn sinh ra sau khi gộp,
    // ta cần một cấu trúc dữ liệu linh hoạt như Priority Queue.
    // Dưới đây là cách kết hợp Sắp xếp và Priority Queue (hoặc queue 2 con)

    queue<long long> q;
    for(long long x : A) q.push(x);

    // Nếu N=1, chi phí là 0
    if (N == 1) {
        cout << 0 << endl;
        return 0;
    }

    // Sử dụng một queue phụ để lưu các tổng mới sinh ra.
    // Vì mảng A đã được sắp xếp, và các tổng mới sinh ra cũng sẽ có thứ tự
    // nếu ta luôn gộp 2 số nhỏ nhất.
    // Đây là kĩ thuật 2 queues để thay thế Priority Queue, độ phức tạp O(N log N) do sort ban đầu.

    queue<long long> new_q;

    // Hàm helper để lấy phần tử nhỏ nhất
    auto get_min = [&]() -> long long {
        if (new_q.empty()) {
            long long val = q.front(); q.pop();
            return val;
        }
        if (q.empty()) {
            long long val = new_q.front(); new_q.pop();
            return val;
        }
        if (q.front() < new_q.front()) {
            long long val = q.front(); q.pop();
            return val;
        } else {
            long long val = new_q.front(); new_q.pop();
            return val;
        }
    };

    while(q.size() > 1 || !new_q.empty()) {
        if (q.empty()) {
             // Chỉ còn trong new_q
             // Cần 2 phần tử
             long long a = new_q.front(); new_q.pop();
             long long b = new_q.front(); new_q.pop();
             long long c = a + b;
             total_cost += c;
             new_q.push(c);
        } else {
            long long a = get_min();
            long long b = get_min();
            long long c = a + b;
            total_cost += c;
            new_q.push(c);
        }
        // Điều kiện dừng: Khi chỉ còn 1 phần tử trong toàn bộ hệ thống
        if (q.empty() && new_q.size() == 1) break;
    }

    cout << total_cost << endl;
    return 0;
}

// Pseudocode minh họa cho cách suy nghĩ sai
// Input: [1, 2, 3, 4]
// Output thực tế mong muốn: 19
// Output của cách này: Sai lệch

void wrong_approach() {
    // Giả sử ta có thanh gỗ ban đầu L = 10.
    // Ta muốn có [1, 2, 3, 4].
    // Cắt 10 -> [4, 6] (cost 10)
    // Cắt 6 -> [2, 4] (cost 6)
    // Cắt 4 -> [1, 3] (cost 4)
    // Cắt 3 -> [3] (đã có 3, không cần cắt thêm, nhưng input có 3, 1, 2, 4)
    // Nhầm: Input có [1,2,3,4].
    // Nếu ta dùng Max-Heap (Luôn cắt thanh lớn nhất) và cắt đôi:
    // 1. Max=10, Cut 10 -> 5, 5. Cost=10. Heap: {5, 5}
    // 2. Max=5, Cut 5 -> 2.5, 2.5 (Không được, vì độ dài phải là số nguyên).
    //    => Vấn đề: Cắt đôi không đảm bảo độ dài nguyên.
    //    => Cần phải biết chính xác điểm cắt.
    //    => Không thể dùng cách tham lam đơn giản trên thanh gỗ ban đầu.