Problem:
Score : 500 points

Problem Statement

Let N be a positive integer.

There is a numerical sequence of length 3N, a = (a_1, a_2, ..., a_{3N}).
Snuke is constructing a new sequence of length 2N, a', by removing exactly N elements from a without changing the order of the remaining elements.
Here, the score of a' is defined as follows: (the sum of the elements in the first half of a') - (the sum of the elements in the second half of a').

Find the maximum possible score of a'.

Constraints

1 ≤ N ≤ 10^5

a_i is an integer.

1 ≤ a_i ≤ 10^9

Partial Score

In the test set worth 300 points, N ≤ 1000.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_{3N}

Output

Print the maximum possible score of a'.

Sample Input 1

2
3 1 4 1 5 9

Sample Output 1

1

When a_2 and a_6 are removed, a' will be (3, 4, 1, 5), which has a score of (3 + 4) - (1 + 5) = 1.

Sample Input 2

1
1 2 3

Sample Output 2

-1

For example, when a_1 are removed, a' will be (2, 3), which has a score of 2 - 3 = -1.

Sample Input 3

3
8 2 2 7 4 6 5 3 8

Sample Output 3

5

For example, when a_2, a_3 and a_9 are removed, a' will be (8, 7, 4, 6, 5, 3), which has a score of (8 + 7 + 4) - (6 + 5 + 3) = 5.

Solution in Haskell (GHC 7.10.3) (judge verdict: Memory Limit Exceeded)

{-# OPTIONS_GHC -O2 #-}
{-# LANGUAGE BangPatterns #-}
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import Data.Array.Unboxed
import Data.Array.ST
import qualified Data.ByteString.Char8 as BS
import Control.Monad
import Data.List
import Data.Char
import qualified Data.Map.Strict as M

fun :: M.Map Int Int -> Int
fun !m = sum [ k*l | (k,l) <- M.toList m ]

push :: M.Map Int Int -> Int -> M.Map Int Int
push !m !k = M.insertWith (+) k 1 m

popMin :: M.Map Int Int -> (Int,M.Map Int Int)
popMin !m = let (k,i) = M.findMin m in if i == 1 then (k,M.delete k m) else (k,M.update (\x -> Just $ x-1) k m)

popMax :: M.Map Int Int -> (Int,M.Map Int Int)
popMax !m = let (k,i) = M.findMax m in if i == 1 then (k,M.delete k m) else (k,M.update (\x -> Just $ x-1) k m)

main :: IO ()
main = do
    n <- readLn
    xs <- unfoldr (BS.readInt . BS.dropWhile isSpace) <$> BS.getLine
    let (as,oo) = splitAt n xs
        (bs,cs) = splitAt n oo
        bb = V.fromList bs
    let u :: V.Vector (M.Map Int Int,Int)
        u = V.create $ do
            u <- VM.new (n+1)
            VM.write u 0 $! (M.fromListWith (+) [(a,1) | a <- as],sum as)
            forM_ [1..n] $ \i-> do
                (m,s) <- VM.read u (i-1)
                let (k,m') = popMin $! push m (bb V.! (i-1))
                VM.write u i $! (m',s-k+(bb V.! (i-1)))
            return u
        v :: V.Vector (M.Map Int Int,Int)
        v = V.create $ do
            v <- VM.new (n+1)
            VM.write v n $! (M.fromListWith (+) [(c,1) | c <- cs],sum cs)
            forM_ [n-1,n-2..0] $ \i -> do
                (m,s) <- VM.read v (i+1)
                let (k,m') = popMax $! push m (bb V.! i)
                VM.write v i $! (m',s-k+(bb V.! i))
            return v
    print $ maximum [ (snd $ (V.!) u i) - (snd $ (V.!) v i) | i <- [0..n] ]