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# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
{
    static void Main(string[] args)
    {
            // 入力
            string sS = System.Console.ReadLine().Trim();
            int iN = int.Parse(sS);
            List<long> lstA = new List<long>();
            for (int k = 0; k < iN; k++)
            {
                lstA.Add(long.Parse(System.Console.ReadLine().Trim()));
            }

            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            sw.Start();

            // 解析
            lstA.Sort();
            List<long> lstB = new List<long>();
            lstB.AddRange(lstA);
            lstB.Reverse();

            List<long> lstC = new List<long>();
            List<long> lstD = new List<long>();
            int i = -1;
            int j = lstA.Count;
            i += 1;
            lstC.Add(lstA[i]);                              // まず最初に中心に最小値
            lstD.Add(lstB[i]);                              // まず最初に中心に最大値
            while (true)
            {
                // 最大値からセット
                j -= 1;                                     // 次の最大値のIndexNo
                if (i == j) { break; }                      // 最大値から見てセット終了
                lstC.Insert(0, lstA[j]);                    // その前に次の最大値
                lstD.Insert(0, lstB[j]);                    // その前に次の最小値
                j -= 1;                                     // 次の最大値のIndexNo
                if (i == j) { break; }                      // 最大値から見てセット終了
                lstC.Add(lstA[j]);                          // その後に次の最大値
                lstD.Add(lstB[j]);                          // その後に次の最小値
                // 最小値からセット
                i += 1;                                     // 次の最小値のIndexNo
                if (i == j) { break; }                      // 最小値から見てセット終了
                lstC.Insert(0, lstA[i]);                    // 次の前に次の最小値
                lstD.Insert(0, lstB[i]);                    // その前に次の最大値
                i += 1;                                     // 次の最小値のIndexNo
                if (i == j) { break; }                      // 最小値から見てセット終了
                lstC.Add(lstA[i]);                          // 次の後に次の最小値
                lstD.Add(lstB[i]);                          // その後に次の最大値
            }
            List<long> lMax = new List<long>() { 0L, 0L };
            for (int k = 0; k < lstC.Count - 1; k++)
            {
                lMax[0] += Math.Abs(lstC[k + 1] - lstC[k]);    // 差の合計
                lMax[1] += Math.Abs(lstD[k + 1] - lstD[k]);    // 差の合計
            }
            lMax.Sort();

            // 出力
            System.Console.WriteLine("{0}", lMax[1].ToString().Trim());

            sw.Stop();
#if DEBUG
            Console.WriteLine();
            Console.WriteLine("{0}", sw.Elapsed.ToString());
            Console.WriteLine("続行するには何かキーを押してください．．．");
            Console.ReadKey();
#endif
    }

}