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 Rust (1.15.1) (judge verdict: Wrong Answer)

use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;
use std::collections::VecDeque;
use std::collections::BinaryHeap;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}
//03:48
fn main(){
    let n: usize = read_as_vec()[0];
    let a = read_as_vec::<i64>();

    let mut half1 = a.clone().into_iter().take(n).map(|x| -x).collect::<BinaryHeap<i64>>();
    let mut half2 = a.clone().into_iter().skip(2*n).collect::<BinaryHeap<i64>>();
    let middle = a.into_iter().skip(n).take(n).collect::<VecDeque<i64>>();

    let mut answers = vec![0;middle.len()+1];

    let mut half1_sum = -half1.iter().sum::<i64>();
    answers[0] = half1_sum;
    for i in 0..middle.len(){
        let half1_min = -half1.pop().unwrap();
        half1_sum -= half1_min;

        half1.push(-middle[i]);
        half1_sum += middle[i];
        answers[i+1] = half1_sum;
    }

    let mut half2_sum = half2.iter().sum::<i64>();
    *answers.last_mut().unwrap() -= half2_sum;

    for i in (0..middle.len()).rev(){
        let half2_max = half2.pop().unwrap();
        half2_sum -= half2_max;

        half2.push(middle[i]);
        half2_sum += middle[i];
        answers[i] -= half2_sum;
    }
    let mut ans = std::i64::MIN;
    for tmp in answers{
        ans = cmp::max(ans, tmp);
    }

    println!("{}", ans);
}