Problem:
Score : 500 points

Problem Statement

On an xy plane, in an area satisfying 0 ≤ x ≤ W, 0 ≤ y ≤ H, there is one house at each and every point where both x and y are integers.

There are unpaved roads between every pair of points for which either the x coordinates are equal and the difference between the y coordinates is 1, or the y coordinates are equal and the difference between the x coordinates is 1.

The cost of paving a road between houses on coordinates (i,j) and (i+1,j) is p_i for any value of j, while the cost of paving a road between houses on coordinates (i,j) and (i,j+1) is q_j for any value of i.

Mr. Takahashi wants to pave some of these roads and be able to travel between any two houses on paved roads only. Find the solution with the minimum total cost.

Constraints

1 ≦ W,H ≦ 10^5

1 ≦ p_i ≦ 10^8(0 ≦ i ≦ W-1)

1 ≦ q_j ≦ 10^8(0 ≦ j ≦ H-1)

p_i (0 ≦ i ≦ W−1) is an integer.

q_j (0 ≦ j ≦ H−1) is an integer.

Input

Inputs are provided from Standard Input in the following form.

W H
p_0
:
p_{W-1}
q_0
:
q_{H-1}

Output

Output an integer representing the minimum total cost.

Sample Input 1

2 2
3
5
2
7

Sample Output 1

29

It is enough to pave the following eight roads.

Road connecting houses at (0,0) and (0,1)

Road connecting houses at (0,1) and (1,1)

Road connecting houses at (0,2) and (1,2)

Road connecting houses at (1,0) and (1,1)

Road connecting houses at (1,0) and (2,0)

Road connecting houses at (1,1) and (1,2)

Road connecting houses at (1,2) and (2,2)

Road connecting houses at (2,0) and (2,1)

Sample Input 2

4 3
2
4
8
1
2
9
3

Sample Output 2

60

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace c
{
    class Program
    {
        public static int Main()
        {
            new Program().calc();
            return 0;
        }

        Scanner sc;

        int w, h;
        public void calc()
        {
            sc = new Scanner();
            w = sc.nextInt();
            h = sc.nextInt();

            int[] p = new int[w];
            int[] q = new int[h];
            long psum = 0;
            long qsum = 0;
            long pmax = 0;
            long qmax = 0;
            for (int i = 0; i < w; i++)
            {
                p[i] = sc.nextInt();
                psum += p[i];
                pmax = Math.Max(pmax, p[i]);
            }
            for (int i = 0; i < h; i++)
            {
                q[i] = sc.nextInt();
                qsum += q[i];
                qmax = Math.Max(qmax, q[i]);
            }

            Kruskal k = new Kruskal((h + 1) * (w * 1));

            for (int i = 0; i < w; i++)
            {
                for (int j = 0; j < h; j++)
                {
                    k.AddPath(getPoint(i, j), getPoint(i + 1, j), p[i]);
                    k.AddPath(getPoint(i, j), getPoint(i, j + 1), q[j]);
                }
            }

            long ans = k.GetCost();
                
            Console.WriteLine(ans);
        }
        int getPoint(int _h, int _w)
        {
            if (h >= w) return _h * h + _w;
            else return _h + _w * w;
        }

        /// <summary>
        /// union find, positive int only
        /// </summary>
        public class UnionFind
        {
            private int[] data;

            public UnionFind(int size)
            {
                data = new int[size];
                for (int i = 0; i < size; i++) data[i] = -1;
            }

            public bool Unite(int x, int y)
            {
                x = Root(x);
                y = Root(y);

                if (x != y)
                {
                    if (data[y] < data[x])
                    {
                        var tmp = y;
                        y = x;
                        x = tmp;
                    }
                    data[x] += data[y];
                    data[y] = x;
                }
                return x != y;
            }

            public bool IsSameGroup(int x, int y)
            {
                return Root(x) == Root(y);
            }

            private int Root(int x)
            {
                return data[x] < 0 ? x : data[x] = Root(data[x]);
            }
        }
        /// <summary>
        /// Vertices index should be positive number
        /// </summary>
        public class Kruskal
        {
            SortedSet<ComparablePair<int, Tuple<int, int>>> pathSet = new SortedSet<ComparablePair<int, Tuple<int, int>>>();

            private int _maxIndex = 1;
            public Kruskal(int maxIndex)
            {
                _maxIndex = maxIndex;
            }

            public void AddPath(int s, int t, int cost)
            {
                var tuple = new Tuple<int, int>(s, t);
                pathSet.Add(new ComparablePair<int, Tuple<int, int>>(cost, tuple));
            }

            public int GetCost()
            {
                int ret = 0;
                var unionFind = new UnionFind(_maxIndex + 1);

                foreach (var path in pathSet)
                {
                    int cost = path.Item1;
                    int vertex1 = path.Item2.Item1;
                    int vertex2 = path.Item2.Item2;

                    if (!unionFind.IsSameGroup(vertex1, vertex2))
                    {
                        unionFind.Unite(vertex1, vertex2);
                        ret += cost;
                    }
                }

                return ret;
            }
        }
    }

    internal class ComparablePair<T1, T2> : Tuple<T1, T2>
    {
        public ComparablePair(T1 item1, T2 item2) : base(item1, item2)
        {
        }
    }

    class Scanner
    {
        string[] s;
        int i;

        char[] cs = new char[] { ' ' };

        public Scanner()
        {
            s = new string[0];
            i = 0;
        }

        public string next()
        {
            while (i >= s.Length)
            {
                string st = Console.ReadLine();
                while (st == "") st = Console.ReadLine();
                s = st.Split(cs, StringSplitOptions.RemoveEmptyEntries);
                i = 0;
            }
            return s[i++];
        }

        public int nextInt()
        {
            return int.Parse(next());
        }

        public long nextLong()
        {
            return long.Parse(next());
        }

        public double nextDouble()
        {
            return double.Parse(next());
        }

    }
}