Problem:
Score : 500 points

Problem Statement

You are going to eat X red apples and Y green apples.

You have A red apples of deliciousness p_1,p_2, \dots, p_A, B green apples of deliciousness q_1,q_2, \dots, q_B, and C colorless apples of deliciousness r_1,r_2, \dots, r_C.

Before eating a colorless apple, you can paint it red or green, and it will count as a red or green apple, respectively.

From the apples above, you will choose the apples to eat while making the sum of the deliciousness of the eaten apples as large as possible.

Find the maximum possible sum of the deliciousness of the eaten apples that can be achieved when optimally coloring zero or more colorless apples.

Constraints

1 \leq X \leq A \leq 10^5

1 \leq Y \leq B \leq 10^5

1 \leq C \leq 10^5

1 \leq p_i \leq 10^9

1 \leq q_i \leq 10^9

1 \leq r_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

X Y A B C
p_1 p_2 ... p_A
q_1 q_2 ... q_B
r_1 r_2 ... r_C

Output

Print the maximum possible sum of the deliciousness of the eaten apples.

Sample Input 1

1 2 2 2 1
2 4
5 1
3

Sample Output 1

12

The maximum possible sum of the deliciousness of the eaten apples can be achieved as follows:

Eat the 2-nd red apple.

Eat the 1-st green apple.

Paint the 1-st colorless apple green and eat it.

Sample Input 2

2 2 2 2 2
8 6
9 1
2 1

Sample Output 2

25

Sample Input 3

2 2 4 4 4
11 12 13 14
21 22 23 24
1 2 3 4

Sample Output 3

74

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using static System.Math;

namespace CsharpSpiral {
    partial class Program {
        static void Main(string[] args) {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(sw);
            new Program().Solve(new ConsoleInput(Console.In, ' '));
            Console.Out.Flush();
        }
		public void Solve(ConsoleInput cin) {
			var line = cin.ReadIntArray(5);
			int X = line[0], Y = line[1], A = line[2], B = line[3], C = line[4];
			var P = cin.ReadLongArray(A);
			var Q = cin.ReadLongArray(B);
			var R = cin.ReadLongArray(C);
			HeapSort(P, true);
			HeapSort(Q, true);
			HeapSort(R, false);
			P = P.Skip(A-X).ToArray();
			Q = Q.Skip(B-Y).ToArray();
			long initial = P.Sum() + Q.Sum();
			long[] replace = new long[C + 1];
			var px = 0;var qy = 0;
			//px+qy+1==i
			for(int i = 1; i <= C; i++) {
				if(px >= X && qy >= Y) break;
				if(px >= X) {
					replace[i] = replace[i - 1] + R[i - 1] - Q[qy];
					qy++;
				} else if(qy >= Y) {
					replace[i] = replace[i - 1] + R[i - 1] - P[px];
					px++;
				} else {
					if(P[px] < Q[qy]) {
						replace[i] = replace[i - 1] + R[i - 1] - P[px];
						px++;
					} else {
						replace[i] = replace[i - 1] + R[i - 1] - Q[qy];
						qy++;
					}
				}
			}
			Console.WriteLine(replace.Max() + initial);
		}
		public static void HeapSort<T>(T[] A, bool Ascending) where T : IComparable<T> {
			var PQ = new PriorityQueue<T>(Ascending);
			PQ.Push(A);
			for(int i = PQ.length - 1; i >= 0; i--) {
				A[i] = PQ.Pop();
			}
		}
	}

	static class ExtendClass {
        public static string Join<T>(this IEnumerable<T> X, string separator = " ") => string.Join(separator, X);
    }

    class ConsoleInput {
        private readonly TextReader _stream;
        private readonly char _separator = ' ';
        private readonly Queue<string> inputStream;
        public ConsoleInput(TextReader stream, char separator = ' ') {
            this._separator = separator;
            this._stream = stream;
            inputStream = new Queue<string>();
        }
        public string Read {
            get {
                if(inputStream.Count != 0) return inputStream.Dequeue();
                string[] tmp = _stream.ReadLine().Split(_separator);
                for(int i = 0; i < tmp.Length; ++i)
                    inputStream.Enqueue(tmp[i]);
                return inputStream.Dequeue();
            }
        }
        public string ReadLine { get { return _stream.ReadLine(); } }
        public int ReadInt { get { return int.Parse(Read); } }
        public long ReadLong { get { return long.Parse(Read); } }
        public double ReadDouble { get { return double.Parse(Read); } }
        public string[] ReadStrArray(long N) {
            var ret = new string[N];
            for(long i = 0; i < N; ++i)
                ret[i] = Read;
            return ret;
        }
        public int[] ReadIntArray(long N) { var ret = new int[N]; for(long i = 0; i < N; ++i) ret[i] = ReadInt; return ret; }
        public long[] ReadLongArray(long N) { var ret = new long[N]; for(long i = 0; i < N; ++i) ret[i] = ReadLong; return ret; }
        public double[] ReadDoubleArray(long N) { var ret = new double[N]; for(long i = 0; i < N; ++i) ret[i] = ReadDouble; return ret; }
    }

	class PriorityQueue<T> where T : IComparable<T> {
		protected readonly List<T> body = new List<T>();
		protected Comparer<T> comparer { get; set; }
		public PriorityQueue(bool maxTop = true) {
			comparer
			= maxTop ? Comparer<T>.Create((T i, T j) => i.CompareTo(j))
			: Comparer<T>.Create((T i, T j) => j.CompareTo(i));
		}
		public PriorityQueue(Comparer<T> mComparer) { comparer = mComparer; }
		//suppose Me>Her if isRootMaximum
		protected int Compare(T Me, T Her) => comparer.Compare(Me, Her);
		protected int Compare(int x, int y) => Compare(body[x], body[y]);
		protected virtual void Swap(int x, int y) { T tmp = body[x]; body[x] = body[y]; body[y] = tmp; }
		public virtual void Push(T elem) {
			body.Add(elem);
			//the parent of n-th element is the ((n+1)>>1)-1-th
			UpHeap(lastIndex);
		}
		public void Push(IEnumerable<T> seq) {
			foreach(var item in seq) {
				Push(item);
			}
		}
		protected int UpHeap(int j) {
			while(j > 0) {
				int parent = ((j + 1) >> 1) - 1;
				if(Compare(parent, j) < 0) {
					Swap(parent, j);
				} else break;
				j = parent;
			}
			return j;
		}
		public virtual T Pop() {
			T top = body[0];
			Swap(0, lastIndex);
			body.RemoveAt(lastIndex);
			DownHeap(0);
			return top;
		}
		protected int DownHeap(int j) {
			while(j < length) {
				var leftChild = ((j + 1) << 1) - 1;
				if(leftChild >= length) break;
				var toSwap = leftChild;
				var rightChild = leftChild + 1;
				if(rightChild < length && Compare(leftChild, rightChild) < 0)
					toSwap = rightChild;
				if(Compare(j, toSwap) < 0) {
					Swap(toSwap, j);
				} else break;
				j = toSwap;
			}
			return j;
		}
		public T Top { get { return body[0]; } }
		public int length { get { return body.Count(); } }
		protected int lastIndex { get { return body.Count() - 1; } }
		public bool Any() => body.Any();
		public string Emit() { return body.ToArray().Join(","); }
	}
}