#ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
 
#include <thread>
#include <unordered_set>
#include <vector>
#include <memory.h>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <stdio.h>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <random>
#include <string>
#include <cassert>


#define getcx _getchar_nolock

using namespace std;
 
namespace std
{
	string to_string(string const& s) { return '"' + s + '"'; }
	string to_string(char c) { return string(1, c); }
	string to_string(const char* s) { return to_string((string)s); }
	string to_string(bool b) { return (b ? "true" : "false"); }
 
	template <class T1, class T2>
	string to_string(pair<T1, T2> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
 
	template <class T>
	string to_string(T c)
	{
		string s = "[";
		for (auto vvv : c) { s += to_string(vvv) + ","; }
		s += "]";
		return s;
	}
 
	void debug_impl() { cerr << endl; };
 
	template <typename T1, typename... T2>
	void debug_impl(T1 a, T2 ... b)
	{
		cerr << " " << to_string(a);
		debug_impl(b...);
	}
}
 
template <typename T>
struct reversion_wrapper
{
	T& iterable;
};
 
template <typename T>
auto begin(reversion_wrapper<T> w) { return std::rbegin(w.iterable); }
 
template <typename T>
auto end(reversion_wrapper<T> w) { return std::rend(w.iterable); }
 
template <typename T>
reversion_wrapper<T> reverse(T&& iterable) { return { iterable }; }
 
 
#ifdef __ASD__
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_impl(__VA_ARGS__)
//#define endl "\n"
#else
#define dbg(...) ;
//#define endl "\n"
#endif
 
#define lng long long

bool less1(char a, char b)
{
	cout << "? " << a << " " << b << endl;
	string r;
	cin >> r;
	return r[0]=='<';
}

void solve5()
{
	int n = 5;
	vector<vector<char>> ps;
	vector<char> p(n);
	iota(p.begin(), p.end(), 'A');
	do
	{
		ps.push_back(p);
	} while(next_permutation(p.begin(), p.end()));

	while (ps.size()>1)
	{
		char a = ' ';
		char b = ' ';
		int d = 1000000;
		for(int i=0;i<26;i++)
		{
			for(int j=i+1;j<26;j++)
			{
				char c1 = 'A'+i;
				char c2 = 'A'+j;
				int l=0;
				int g=0;
				for(auto &p : ps)
				{
					int i1 = find(p.begin(), p.end(), c1) - p.begin();
					int i2 = find(p.begin(), p.end(), c2) - p.begin();
					if (i1<i2)l++;else g++;
				}
				if (abs(l-g) < d)
				{
					d = abs(l-g);
					a = c1;
					b = c2;
				}
			}
		}

		bool l = less1(a,b);

		vector<vector<char>>psn;
		for(auto &p : ps)
		{
			int i1 = find(p.begin(), p.end(), a) - p.begin();
			int i2 = find(p.begin(), p.end(), b) - p.begin();
			if ((i1<i2)==(l))psn.push_back(p);
		}
		ps = psn;
	}

	cout <<"! ";
	for(char c : *ps.begin())
	{
		cout<<"" << c;
	}
	cout<<endl;
}

string alpha;

string merge(string s1, string s2)
{
	int l1 = s1.length();
	int l2 = s2.length();
	string res = "";
	int i=0;
	int j=0;

	while (i<l1 && j<l2)
	{
		bool l = less1(s1[i], s2[j]);
		if (l)res+=s1[i++];
		else res+=s2[j++];
	}

	while (i<l1)res+=s1[i++];
	while (j<l2)res+=s2[j++];
	

	return res;
}

string sort(int l, int r)
{
	if (r-l==1)
	{
		return alpha.substr(l, 1);
	}

	int m = (l+r)/2;
	string s1 = sort(l, m);
	string s2 = sort(m, r);

	return merge(s1, s2);
}

void solve26()
{
	for(char c='A';c<='Z';c++)alpha+=c;

	string res = sort(0, 26);

	cout <<"! " << res << endl;
}

int main()
{
#ifdef __ASD__
	auto start_t = chrono::steady_clock::now();
	freopen("input.txt", "r", stdin);
	//freopen("nul", "w", stderr);
	//freopen("output.txt", "w",  stdout);
#else
	ios_base::sync_with_stdio(false);
#endif

	int n;
	cin >> n;
	
	vector<int> a(n);
	for(int i=0;i<n;i++)
	{
		cin>>a[i];
		a[i]--;
	}
	
	vector<int> b(n);
	for(int i=0;i<n;i++)
	{
		cin>>b[i];
	}
	
	vector<int> c(n-1);
	for(int i=0;i<n-1;i++)
	{
		cin>>c[i];
	}
	int res=0;
	for(int i=0;i<n;i++)
	{
		res+=b[i];
	}

	for(int i=1;i<n;i++)
	{
		if (a[i]-a[i-1]==1)
		{
			res+=c[a[i-1]];
		}
	}

	cout<<res<<endl;

#ifdef __ASD__
	auto finish_t = chrono::steady_clock::now();
	cerr << "Elapsed " << chrono::duration_cast<chrono::milliseconds>(finish_t - start_t).count() << " ms" << endl;
#endif
	return 0;
}


Measured memory_bytes: 256