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: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace AtCoder
{
    class Node
    {
        private int m_height;
        private Node m_parent;
        public Node()
        {
            m_height = 0;
            m_parent = this;
        }
        public Node Find()
        {
            if (m_parent == this) { return this; }

            Node parent = m_parent.Find();
            m_parent = parent;
            return parent;
        }
        public static void Unite(Node a, Node b)
        {
            Node p = a.Find();
            Node q = b.Find();
            if (p.m_height < q.m_height)
            {
                p.m_parent = q;
                q.m_height = Math.Max(p.m_height + 1, q.m_height);
            }
            else
            {
                q.m_parent = p;
                p.m_height = Math.Max(q.m_height + 1, p.m_height);
            }
        }
    }

    class Program
    {
        private static string Read() { return Console.ReadLine(); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }

        struct Point
        {
            public int x;
            public int y;
        }

        struct Edge
        {
            public int cost;
            public Point from;
            public Point to;
        }

        static long Solve(int W, int H, int[] P, int[] Q)
        {
            var nodes = new Node[H + 1][];
            for (int y = 0; y <= H; ++y)
            {
                nodes[y] = new Node[W + 1];
                for (int x = 0; x <= W; ++x) { nodes[y][x] = new Node(); }
            }
            var edges = new List<Edge>();
            for (int y = 0; y <= H; ++y)
            {
                for (int x = 0; x <= W; ++x)
                {
                    var from = new Point { x = x, y = y };
                    var to1 = new Point { x = x + 1, y = y };
                    var to2 = new Point { x = x, y = y + 1 };
                    if (to1.x <= W) { edges.Add(new Edge { cost = P[x], from = from, to = to1 }); }
                    if (to2.y <= H) { edges.Add(new Edge { cost = Q[y], from = from, to = to2 }); }
                }
            }
            long sum = 0;
            foreach (var edge in edges.OrderBy(edge => edge.cost))
            {
                var from = edge.from;
                var to = edge.to;
                var a = nodes[from.y][from.x];
                var b = nodes[to.y][to.x];
                if (a.Find() != b.Find())
                {
                    Node.Unite(a, b);
                    sum += edge.cost;
                }
            }
            return sum;
        }

        static void Main(string[] args)
        {
            int[] V = ReadInts();
            int W = V[0], H = V[1];
            var P = new int[W];
            for (int i = 0; i < W; ++i) { P[i] = ReadInt(); }
            var Q = new int[H];
            for (int i = 0; i < H; ++i) { Q[i] = ReadInt(); }
            Console.WriteLine(Solve(W, H, P, Q));
        }
    }
}