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 Ruby (2.3.3) (judge verdict: Accepted)

class PriorityQueue
  attr_reader :size

  def initialize(order: :asc)
    @size = 0
    @nodes = []
  end

  def empty?
    @size.zero?
  end

  def push(node)
    index = size

    while index > 0
      parent = (index - 1) / 2

      break if @nodes[parent].last <= node.last

      @nodes[index] = @nodes[parent]
      index = parent
    end

    @nodes[index] = node
    @size += 1
  end

  alias_method :<<, :push

  def pop
    node = @nodes.first
    @nodes[0], @nodes[size - 1] = @nodes[size - 1], nil
    index = 0

    while index * 2 + 1 < @size
      left = 2 * index + 1
      right = left + 1

      target = if @nodes[left] && @nodes[right]
                 (@nodes[left].last <=> @nodes[right].last) < 0 ? left : right
               elsif @nodes[left]
                 left
               elsif @nodes[right]
                 right
               else
                 nil
               end

      break if target.nil?
      break if (@nodes[target].last <=> @nodes[index].last) >= 0

      @nodes[index], @nodes[target] = @nodes[target], @nodes[index]
      index = target
    end

    @size -= 1
    node.first
  end

  def top
    @nodes.first
  end
end

N = gets.to_i
A = gets.split.map(&:to_i)

front = PriorityQueue.new
front_sum = 0

back = PriorityQueue.new(order: :desc)
back_sum = 0

N.times do
  v = A.shift
  front.push([v, v])
  front_sum += v

  w = A.pop
  back.push([w, -w])
  back_sum += w
end

f_sums = [front_sum]
b_sums = [back_sum]

A.each do |a|
  if front.top[0] < a
    front_sum -= front.pop
    front.push([a, a])
    front_sum += a
  end

  f_sums << front_sum
end

A.reverse_each do |a|
  if back.top[0] > a
    back_sum -= back.pop
    back.push([a, -a])
    back_sum += a
  end

  b_sums << back_sum
end

puts f_sums.zip(b_sums.reverse).map { |a, b| a - b }.max