Problem:
Score : 400 points

Problem Statement

You are given N integers; the i-th of them is A_i.
Find the maximum possible sum of the absolute differences between the adjacent elements after arranging these integers in a row in any order you like.

Constraints

2 \leq N \leq 10^5

1 \leq A_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

Print the maximum possible sum of the absolute differences between the adjacent elements after arranging the given integers in a row in any order you like.

Sample Input 1

5
6
8
1
2
3

Sample Output 1

21

When the integers are arranged as 3,8,1,6,2, the sum of the absolute differences between the adjacent elements is |3 - 8| + |8 - 1| + |1 - 6| + |6 - 2| = 21. This is the maximum possible sum.

Sample Input 2

6
3
1
4
1
5
9

Sample Output 2

25

Sample Input 3

3
5
5
1

Sample Output 3

8

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define repr(e,x) for(auto& e:x)
using namespace std;
typedef long long ll;

int N;
int A[100000];
deque<int> deq;

int main(){
    cin>>N;
    rep(i,N) cin>>A[i];

    sort(A,A+N);

    ll ans=0;

    int l=1, r=N-1;
    bool right=true;
    int cnt=0;
    deq.push_back(A[0]);
    repn(i,N-1){
        if(right){
            if(cnt==0){
                deq.push_front(A[r]);
                r--;
                cnt++;
            }else if(cnt==1){
                deq.push_back(A[r]);
                r--;
                cnt=0;
                right=false;
            }
        }else{
            if(cnt==0){
                deq.push_front(A[l]);
                l++;
                cnt++;
            }else if(cnt==1){
                deq.push_back(A[l]);
                l++;
                cnt=0;
                right=true;
            }
        }
    }
    ll res=0;
    int a1,a2=deq.front();
    deq.pop_front();
    rep(i,N-1){
        a1=a2;
        a2=deq.front();
        deq.pop_front();
        res+=abs(a1-a2);
    }
    ans=max(ans,res);



    l=0, r=N-2;
    right=false;
    cnt=0;
    deq.clear();
    deq.push_back(A[N-1]);
    repn(i,N-1){
        if(right){
            if(cnt==0){
                deq.push_front(A[r]);
                r--;
                cnt++;
            }else if(cnt==1){
                deq.push_back(A[r]);
                r--;
                cnt=0;
                right=false;
            }
        }else{
            if(cnt==0){
                deq.push_front(A[l]);
                l++;
                cnt++;
            }else if(cnt==1){
                deq.push_back(A[l]);
                l++;
                cnt=0;
                right=true;
            }
        }
    }
    res=0;
    a1=0,a2=deq.front();
    deq.pop_front();
    rep(i,N-1){
        a1=a2;
        a2=deq.front();
        deq.pop_front();
        res+=abs(a1-a2);
    }
    ans=max(ans,res);

    cout<<ans<<endl;
}