Arkady and Masha want to choose decorations for thier aquarium in Fishdom game. They have n decorations to choose from, each of them has some cost. To complete a task Arkady and Masha need to choose exactly m decorations from given, and they want to spend as little money as possible.There is one difficulty: Masha likes some a of the given decorations, Arkady likes some b of the given decorations. Some decorations may be liked by both Arkady and Masha, or not be liked by both. The friends want to choose such decorations so that each of them likes at least k decorations among the chosen. Help Masha and Arkady find the minimum sum of money they need to spend.

The first line contains three integers n, m and k (1 ≤ n ≤ 200000, 1 ≤ m ≤ n, 1 ≤ k ≤ n) — the number of decorations, how many decorations the friends should choose, how many decorations each of them should like among the chosen. The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 109) — decorations costs. The third line contains single integer a (1 ≤ a ≤ n) — the number of decorations liked by Masha. The fourth line contains a distinct integers x1, x2, ..., xa (1 ≤ xi ≤ n) — the ids of decorations liked by Masha. The next two lines describe decorations liked by Arkady in the same format.

Print single integer: the minimum sum of money the friends should spend to fulfill all constraints. If it is not possible, print -1.

NoteIn the first example the only possible variant to choose 3 decorations having all conditions satisfied is to choose decorations 1, 2, 3.In the second example friends can choose decoration 4 instead of decoration 3, because this one is one coin cheaper.In the third example it's not possible to choose 2 decorations in a way that both are liked by both Masha and Arkady.

import core.bitop;
import core.checkedint;
import core.simd;
import core.stdc.stdlib;
import core.stdc.string;
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.bitmanip;
import std.complex;
import std.container;
import std.conv;
import std.datetime;
import std.format;
import std.functional;
import std.math;
import std.meta;
import std.numeric;
import std.random;
import std.range;
import std.regex;
import std.stdio;
import std.string;
import std.typecons;
import std.variant;

__gshared:

alias BitSet(size_t n) = size_t[(n + size_t.sizeof * 8 - 1) / (size_t.sizeof * 8)];

auto getAddrTuple() {
    return tuple();
}

auto getAddrTuple(T, U...)(ref T head, ref U tail) {
    return tuple(&head, getAddrTuple(tail).expand);
}

bool read(T...)(ref T vars) if (vars.length > 0) {
    return readf(' ' ~ replicate("%s ", vars.length), getAddrTuple(vars).expand) == vars.length;
}

T[ ] allocate(T)(size_t n) {
    return (cast(T*)malloc(n * T.sizeof))[0 .. n];
}

auto pairwise(R)(R range) if (isForwardRange!R) {
    return lockstep(range, dropOne(range));
}

enum { NONE, M, A, BOTH }

int n, m, k;
int[2 * 10^^5] prices;
ubyte[2 * 10^^5] masks;
int[ ][4] things;

void main() {
    while (read(n, m, k)) {
        version (LocalProject) {
            masks[ ] = 0x0;
            things[ ] = null;
        }
        foreach (ref x; prices[0 .. n])
            read(x);
        int a;
        foreach (i; 0x1 .. 0x3) {
            read(a);
            int x;
            while (a--) {
                read(x);
                masks[x - 1] |= i;
            }
        }
        foreach (i; 0 .. n)
            things[masks[i]] ~= prices[i];
        things.each!sort();

        ulong[4] sums;
        int[4] ind;

        void increase3(int count) {
            while (count--) {
                int best = int.max, bestI = -1;
                if (ind[NONE] < things[NONE].length) {
                    best = things[NONE][ind[NONE]];
                    bestI = NONE;
                }
                if (ind[M] < things[M].length && things[M][ind[M]] < best) {
                    best = things[M][ind[M]];
                    bestI = M;
                }
                if (ind[A] < things[A].length && things[A][ind[A]] < best) {
                    best = things[A][ind[A]];
                    bestI = A;
                }
                if (!~bestI)
                    break;
                sums[bestI] += best;
                ind[bestI]++;
            }
        }

        void decrease3(int count) {
            const lim = max(0, k - ind[BOTH]);
            while (count--) {
                int best = -1, bestI = -1;
                if (ind[NONE]) {
                    best = things[NONE][ind[NONE] - 1];
                    bestI = NONE;
                }
                if (ind[M] > lim && things[M][ind[M] - 1] > best) {
                    best = things[M][ind[M] - 1];
                    bestI = M;
                }
                if (ind[A] > lim && things[A][ind[A] - 1] > best) {
                    best = things[A][ind[A] - 1];
                    bestI = A;
                }
                if (!~bestI)
                    break;
                sums[bestI] -= best;
                ind[bestI]--;
            }
        }

        bool isValid() {
            return ind[M] + ind[BOTH] >= k && ind[A] + ind[BOTH] >= k && sum(ind[ ]) == m;
        }

        ind[M] = min(k, things[M].length);
        ind[A] = min(k, things[A].length);
        foreach (x; things[M][0 .. ind[M]])
            sums[M] += x;
        foreach (x; things[A][0 .. ind[A]])
            sums[A] += x;
        ulong result = ulong.max;
        if (ind[M] == k && ind[A] == k && m >= k << 1) {
            increase3(m - (k << 1));
            if (isValid())
                result = sum(sums[ ]);
        }
        for (ind[BOTH] = 1; ind[BOTH] <= things[BOTH].length; ind[BOTH]++) {
            sums[BOTH] += things[BOTH][ind[BOTH] - 1];
            decrease3(3);
            increase3(3);
            int taken = sum(ind[ ]);
            if (taken > m)
                decrease3(taken - m);
            else if (taken < m)
                increase3(m - taken);
            if (isValid())
                result = min(result, sum(sums[ ]));
        }
        writeln(cast(long)result);
    }
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,std.functional,
	std.math,std.string,std.range,std.complex,std.bitmanip,std.typecons,std.regex,std.random,
	std.uni,std.traits,std.stdio,std.variant,core.bitop,std.meta,std.datetime,
	core.stdc.stdio : freopen;import std.numeric: fft,Fft,gcd,inverseFft;
alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");alias mp=make_pair;alias pii=pair!(int,int);
alias lint=long;alias rbt=RedBlackTree;private const int mod=10^^9+7;alias pll=pair!(long,long);
alias gcd=std.numeric.gcd;
public
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
public
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	debug
	{
		StopWatch sw;
		sw.start;
		scope(exit)
		{
			sw.stop;
			stderr.writefln("Time: %d ms",sw.peek.msecs);
		}
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*max(k-x,0)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		debug enter(pos);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//alias true=false;
		debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),
		q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=min(pos,sz(v[3])-x);
		foreach(i;0..len)
		{
			if(v[3][x] in q1)
			{
				q1.removeKey(v[3][x]);
				ss-=v[3][x];
			}
			else q2.removeKey(v[3][x]);
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			//y+=2;
			y++;
			ss+=v[3][x];
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
			//if(x+y!=m)assert(false);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*max(k-x,0)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		debug enter(pos);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//alias true=false;
		debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),
		q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=min(pos,sz(v[3])-x);
		foreach(i;0..len)
		{
			if(!q1.equalRange(v[3][x]).empty)
			{
				q1.removeKey(v[3][x]);
				ss-=v[3][x];
			}
			else q2.removeKey(v[3][x]);
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			//y+=2;
			y++;
			ss+=v[3][x];
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
			//if(x+y!=m)assert(false);
		}
		writeln(ans);
	}
}

import core.bitop;
import core.checkedint;
import core.simd;
import core.stdc.stdlib;
import core.stdc.string;
import std.algorithm;
import std.array;
import std.ascii;
import std.bigint;
import std.bitmanip;
import std.complex;
import std.container;
import std.conv;
import std.datetime;
import std.format;
import std.functional;
import std.math;
import std.meta;
import std.numeric;
import std.random;
import std.range;
import std.regex;
import std.stdio;
import std.string;
import std.typecons;
import std.variant;

__gshared:

alias BitSet(size_t n) = size_t[(n + size_t.sizeof * 8 - 1) / (size_t.sizeof * 8)];

auto getAddrTuple() {
    return tuple();
}

auto getAddrTuple(T, U...)(ref T head, ref U tail) {
    return tuple(&head, getAddrTuple(tail).expand);
}

bool read(T...)(ref T vars) if (vars.length > 0) {
    return readf(' ' ~ replicate("%s ", vars.length), getAddrTuple(vars).expand) == vars.length;
}

T[ ] allocate(T)(size_t n) {
    return (cast(T*)malloc(n * T.sizeof))[0 .. n];
}

auto pairwise(R)(R range) if (isForwardRange!R) {
    return lockstep(range, dropOne(range));
}

enum { NONE, M, A, BOTH }

int n, m, k;
int[2 * 10^^5] prices;
ubyte[2 * 10^^5] masks;
int[ ][4] things;

void main() {
    while (read(n, m, k)) {
        version (LocalProject) {
            masks[ ] = 0x0;
            things[ ] = null;
        }
        foreach (ref x; prices[0 .. n])
            read(x);
        int a;
        foreach (i; 0x1 .. 0x3) {
            read(a);
            int x;
            while (a--) {
                read(x);
                masks[x - 1] |= i;
            }
        }
        foreach (i; 0 .. n)
            things[masks[i]] ~= prices[i];
        foreach (i; 0 .. 4)
            things[i].sort();

        ulong[4] sums;
        int[4] ind;

        void increase3(int count) {
            while (count--) {
                int best = int.max, bestI = -1;
                if (ind[NONE] < things[NONE].length) {
                    best = things[NONE][ind[NONE]];
                    bestI = NONE;
                }
                if (ind[M] < things[M].length && things[M][ind[M]] < best) {
                    best = things[M][ind[M]];
                    bestI = M;
                }
                if (ind[A] < things[A].length && things[A][ind[A]] < best) {
                    best = things[A][ind[A]];
                    bestI = A;
                }
                if (!~bestI)
                    break;
                sums[bestI] += things[bestI][ind[bestI]++];
            }
        }

        void decrease3(int count) {
            const lim = max(0, k - ind[BOTH]);
            while (count--) {
                int best = -1, bestI = -1;
                if (ind[NONE]) {
                    best = things[NONE][ind[NONE] - 1];
                    bestI = NONE;
                }
                if (ind[M] > lim && things[M][ind[M] - 1] > best) {
                    best = things[M][ind[M] - 1];
                    bestI = M;
                }
                if (ind[A] > lim && things[A][ind[A] - 1] > best) {
                    best = things[A][ind[A] - 1];
                    bestI = A;
                }
                if (!~bestI)
                    break;
                sums[bestI] -= things[bestI][--ind[bestI]];
            }
        }

        bool isValid() {
            return ind[M] + ind[BOTH] >= k && ind[A] + ind[BOTH] >= k && sum(ind[ ]) == m;
        }

        ind[M] = min(k, things[M].length);
        ind[A] = min(k, things[A].length);
        foreach (x; things[M][0 .. ind[M]])
            sums[M] += x;
        foreach (x; things[A][0 .. ind[A]])
            sums[A] += x;
        ulong result = ulong.max;
        if (ind[M] == k && ind[A] == k && m >= k << 1) {
            increase3(m - (k << 1));
            if (isValid())
                result = sum(sums[ ]);
        }
        for (ind[BOTH] = 1; ind[BOTH] <= things[BOTH].length; ind[BOTH]++) {
            sums[BOTH] += things[BOTH][ind[BOTH] - 1];
            int taken = sum(ind[ ]);
            if (taken > m)
                decrease3(taken - m);
            else if (taken < m)
                increase3(m - taken);
            if (isValid())
                result = min(result, sum(sums[ ]));
        }
        writeln(cast(long)result);
    }
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				ss+=v[3][x];
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
			}
			else
			{
				if(q1.back<v[3][x])break;
				else if(q1.back>v[3][x])q1.removeBack;
			}
			if(!q1.equalRange(v[3][x]).empty)
			{
				q1.removeKey(v[3][x]);
				ss-=v[3][x];
			}
			else q2.removeKey(v[3][x]);
			//q1.insert(v[3][x]);
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				if(q2.front>=q1.back)break;
				else
				{
					ss-=q1.back;
					q1.removeBack;
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				ss+=v[3][x];
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
			}
			else
			{
				if(q1.back<v[3][x])break;
				else if(q1.back>v[3][x])
				{
					ss-=q1.back;
					q1.removeBack;
				}
			}
			if(!q1.equalRange(v[3][x]).empty)
			{
				q1.removeKey(v[3][x]);
				ss-=v[3][x];
			}
			else q2.removeKey(v[3][x]);
			//q1.insert(v[3][x]);
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		debug enter(pos);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//alias true=false;
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),
		q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos && y>0)
			{
				if(!q1.equalRange(v[3][x]).empty)
				{
					q1.removeKey(v[3][x]);
					ss-=v[3][x];
				}
				else q2.removeKey(v[3][x]);
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				//y+=2;
				y--;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				break;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			y+=2;
			if(!q1.equalRange(v[3][x]).empty)q1.removeKey(v[3][x]);
			else q2.removeKey(v[3][x]);
			//q1.insert(v[3][x]);
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			ans=min(ans,ss);
			x++;
		}
		foreach(i;x..sz(v[3]))
		{
			if(v[3][i]>=q1.back)break;
			ss-=q1.back;
			q1.removeBack;
			ss+=v[3][i];
			q1.insert(v[3][i]);
			ans=min(ans,ss);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				if(!q1.equalRange(v[3][x]).empty)
				{
					q1.removeKey(v[3][x]);
					ss-=v[3][x];
				}
				else q2.removeKey(v[3][x]);
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeKey(q2.front);
				}
			}
			else
			{
				break;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		debug enter(pos);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//alias true=false;
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),
		q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=min(y,pos);
		foreach(i;0..len)
		{
			if(!q1.equalRange(v[3][x]).empty)
			{
				q1.removeKey(v[3][x]);
				ss-=v[3][x];
			}
			else q2.removeKey(v[3][x]);
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			//y+=2;
			y++;
			ss+=v[3][x];
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
			//if(x+y!=m)assert(false);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				if(q2.front>=q1.back && v[3][x]>=q1.back)break;
				else
				{
					q2.insert(v[3][x]);
					ss-=q1.back;
					q1.removeBack;
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			y+=2;
			ans=min(ans,ss);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m);
		if(min(k,sz(v[1]))+min(k,sz(v[2]))+x+sz(v[0])<m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		int pos=k-x;
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			y+=2;
			ans=min(ans,ss);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			y+=2;
			if(!q1.equalRange(v[3][x]).empty)q1.removeKey(v[3][x]);
			else q2.removeKey(v[3][x]);
			//q1.insert(v[3][x]);
			while(q1.length<y)
			{
				ss+=q2.front;
				q1.insert(q2.front);
				q2.removeFront;
			}
			ans=min(ans,ss);
			x++;
		}
		foreach(i;x..sz(v[3]))
		{
			if(v[3][i]>=q1.back)break;
			ss-=q1.back;
			q1.removeBack;
			ss+=v[3][i];
			q1.insert(v[3][i]);
			ans=min(ans,ss);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{

				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				if(!q1.equalRange(v[3][x]).empty)
				{
					q1.removeKey(v[3][x]);
					ss-=v[3][x];
				}
				else q2.removeKey(v[3][x]);
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				break;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			y+=2;
			ans=min(ans,ss);
			x++;
		}
		foreach(i;x..sz(v[3]))
		{
			if(v[3][i]>=q1.back)break;
			ss-=q1.back;
			q1.removeBack;
			ss+=v[3][i];
			q1.insert(v[3][i]);
			ans=min(ans,ss);
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				if(!q1.equalRange(v[3][x]).empty)
				{
					q1.removeKey(v[3][x]);
					ss-=v[3][x];
				}
				else q2.removeKey(v[3][x]);
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				break;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]~v[3][x..$]);
		sort(s);
		//alias true=false;
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",false) q1=new rbt!(lint,"a<b",false)(s[0..y]),q2=new rbt!(lint,"a<b",false)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				if(!q1.equalRange(v[3][x]).empty)
				{
					q1.removeKey(v[3][x]);
					ss-=v[3][x];
				}
				else q2.removeKey(v[3][x]);
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				break;
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!lint;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new lint[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		//debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		//debug enter(s.length,' ',y);
		rbt!(lint,"a<b",true) q1=new rbt!(lint,"a<b",true)(s[0..y]),q2=new rbt!(lint,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+1L*v[2][i];
		}
		long ss=ans;
		int len=sz(v[3])-x;
		foreach(i;0..len)
		{
			if(i<pos)
			{
				ss-=v[1][pos-i-1]+v[2][pos-i-1];
				q2.insert(v[1][pos-i-1]);
				q2.insert(v[2][pos-i-1]);
				y+=2;
				ss+=v[3][x];
				while(q1.length<y)
				{
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			else
			{
				if(q2.front>=q1.back)break;
				else
				{
					q2.insert(v[3][x]);
					ss-=q1.back;
					q1.removeBack;
					ss+=q2.front;
					q1.insert(q2.front);
					q2.removeFront;
				}
			}
			//q1.insert(v[3][x]);
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			y+=2;
			ans=min(ans,ss);
			x++;
		}
		writeln(ans);
	}
}

module main;
import std.bigint,std.container,std.array,std.algorithm,std.conv,std.parallelism,
	std.functional,std.math,std.string,std.range,std.complex,std.bitmanip,
	std.typecons,std.regex,std.random,std.uni,std.traits,std.stdio,std.variant,core.bitop,
	std.meta,core.stdc.stdio : freopen;
import std.numeric: fft,Fft,gcd,inverseFft;alias big=BigInt;alias pair(X,Y)=Tuple!(X,"fi",Y,"se");
alias lint=long;private const int mod=1_000_000_007;alias rbt=RedBlackTree;
alias pii=pair!(int,int);alias pll=pair!(long,long);alias mp=make_pair;alias gcd=std.numeric.gcd;
private
{
	pure nothrow
	{
		T lcm (T)(auto ref T a,auto ref T b){return a/gcd(a,b)*b;}
		pair!(X,Y) make_pair(X,Y)(in X x_,in Y y_){return tuple!(X,"fi",Y,"se")(x_,y_);}
		big gcd(big a,big b){while(b){a%=b;swap(a,b);}return a;}
		@property X sqr(X)(in X a_) {return a_*a_;}
		@property X cub(X)(in X a_) {return a_*a_*a_;}
		int sz(T)(T a) if(hasLength!T){return cast(int)a.length;}
		size_t lowb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(!(a[m]<g))r=m;
				else l=m;
			}
			return (!(a[l]<g))?l:r;
		}
		size_t upb(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			size_t l=0,r=a.length;
			while(r-l>1)
			{
				auto m=(l+r)>>1;
				if(g<a[m])r=m;
				else l=m;
			}
			return (g<a[l])?l:r;
		}
		size_t binf(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			auto pos=lowb(a,g);
			return (g==a[pos])?pos:a.length;
		}
		bool binary_search(T,X)(T a,auto ref X g)
		if(isRandomAccessRange!T && hasLength!T && is(typeof(g<a[0])==bool))
		{
			return binf(a,g)!=a.length;
		}
	}
	void putarr(X)(in X a,in char ch=' ') if(isInputRange!X && !isInputRange!(ElementEncodingType!X))
	{foreach(const ref i;a)write(i,ch);}
	void putarr(X)(in X a) if(isInputRange!X && isInputRange!(ElementEncodingType!X))
	{
		foreach(ref const i;a)
		{
			foreach(ref const j;i)write(j,' ');
			writeln;
		}
	}
	bool getarr(X)(X a,in size_t n)
	{bool b=1; foreach(ref i;a[0..n])b=input(&i);return b;}
	bool input(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		return s==ptrs.length;
	}
	bool read(T...)(auto ref T ptrs) if (ptrs.length > 0)
	{
		size_t s=0;
		foreach(ref e;ptrs)
		{
			if(isSomeChar!(Unqual!(typeof(e))))s+=readf(" %c",&e);
			else s+=readf(" %s",&e);
		}
		readln;
		return s==ptrs.length;
	}
	nothrow auto inf(in char* name) {return freopen(name,"r",core.stdc.stdio.stdin);}
	nothrow auto ouf(in char* name) {return freopen(name,"w",core.stdc.stdio.stdout);}
	@property auto arread(T)(){return readln.splitter.map!(to!(T)).array;}
	void enter(T...)(T args)
	{
		writeln(args);
		stdout.flush;
	}
}
//foreach_reverse isAlpha isNumber isWhite isLower isUpper toLower toUpper mixin
//cumulativeFold return static heapify join filter foreach
//------------------------------------------program beginning--------------------------
private
{

}
void main()
{
	version(home)
	{
		assert(freopen("input.txt","r",core.stdc.stdio.stdin));
		assert(freopen("output.txt","w",core.stdc.stdio.stdout));
	}
	int n,k,m;
loop:while(read(n,m,k))
	{
		auto c=arread!int;
		int a;
		read(a);
		auto ma=arread!int;
		int b;
		read(b);
		auto mb=arread!int;
		auto u=new int[c.length];
		foreach(x;ma)
		{
			u[x-1]+=1;
		}
		foreach(x;mb)
		{
			u[x-1]+=2;
		}
		auto v=new int[][4];
		foreach(i;0..c.length)
		{
			v[u[i]]~=c[i];
		}
		v.each!sort;
		int x=max(0,k-sz(v[1]),k-sz(v[2]),2*k-m,m-sz(v[0])-sz(v[1])-sz(v[2]));
		if(2*(k-x)+x>m)
		{
			writeln(-1);
			continue loop;
		}
		if(x>v[3].length)
		{
			writeln(-1);
			continue loop;
		}
		debug writeln(x);
		int pos=max(k-x,0);
		int y=m-(2*pos+x);
		auto s=(v[0]~v[1][pos..$]~v[2][pos..$]);
		sort(s);
		debug enter(s.length,' ',y);
		rbt!(int,"a<b",true) q1=new rbt!(int,"a<b",true)(s[0..y]),q2=new rbt!(int,"a<b",true)(s[y..$]);
		long ans;
		foreach(i;0..y)
		{
			ans+=s[i];
		}
		foreach(i;0..x)
		{
			ans+=v[3][i];
		}
		foreach(i;0..pos)
		{
			ans+=v[1][i]+v[2][i];
		}
		long ss=ans;
		foreach(i;0..min(pos,sz(v[3])-x,sz(q2)/2))
		{
			ss+=v[3][x];
			ss-=v[1][pos-i-1]+v[2][pos-i-1];
			q2.insert(v[1][pos-i-1]);
			q2.insert(v[2][pos-i-1]);
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			ss+=q2.front;
			q1.insert(q2.front);
			q2.removeFront;
			y+=2;
			ans=min(ans,ss);
			x++;
		}
		foreach(i;x..sz(v[3]))
		{
			if(v[3][i]>=q1.back)break;
			ss-=q1.back;
			q1.removeBack;
			ss+=v[3][i];
			q1.insert(v[3][i]);
			ans=min(ans,ss);
		}
		writeln(ans);
	}
}