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);
	}
}

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);
	}
}

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);
    }
}

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);
	}
}