#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <queue>
#include <cstdio>
#include <deque>
#include <map>
#include <vector>
#include <list>
#include <functional>
#include <stack>
#include <unordered_map>
#include <set>
#include <cctype>
#include <cstring>
#include <tuple>
#include <bitset>
#include <unordered_set>
#include <iomanip>
#include <utility>
#include <ctime>
#include <iterator>
#include <numeric>
#include <random>
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define MAX(a,b) (a>b?a:b)
#define MIN(a,b) (a<b?a:b)
#define g0(a) get<0>(a)
#define g1(a) get<1>(a)
#define g2(a) get<2>(a)
#define g3(a) get<3>(a)
using namespace std;
typedef unsigned short us;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef unsigned __int128 ulll;
typedef unsigned int uint;
typedef unsigned char uc;
typedef unsigned short us;
typedef long double ld;
const int M=1e9+9,N=2e5+5,LOGN=20,YI=1,LING=0,MOD=1e9+7; const ll LM=1e18+18,P=133377773331ll;
int n,logn;
ll ans;
struct ai
{
	int a,i;
}
a[N*2];
ull xx[N],pp[N];
struct hh
{
	ull a;
	int len;
	hh():len(1){}
	hh(const ull x,const int l):a(x),len(l){}
	hh operator + (const hh &x) {return hh(a*pp[x.len]+x.a,len+x.len);}
	bool operator == (const hh &x) {return a==x.a&&len==x.len;}
};
namespace xds
{
	struct node
	{
		int l,r,mid;
		hh hl,hr;
	}
	tree[N*4];

	int l,r,x,k;

	#define li i*2
	#define ri li+1
	#define p tree[i]
	#define lz tree[li]
	#define rz tree[ri]
	#define bao (p.l>=l&&p.r<=r)
	#define wu (p.l>r||p.r<l)
	#define up p.hl=lz.hl+rz.hl,p.hr=rz.hr+lz.hr;

	void build(const int i,const int l,const int r)
	{
		p.l=l,p.r=r,p.mid=(l+r)>>1;
		if(l==r) p.hl.a=p.hr.a=xx[l];
		else build(li,l,p.mid),build(ri,p.mid+1,r),up;
	}

	void change(const int i=1)
	{
		if(wu) return ;
		if(bao) p.hl.a=p.hr.a=xx[k];
		else change(li),change(ri),up;
	}

	hh ask_l(const int i=1)
	{
		if(bao) return p.hl;
		if(p.mid>=r) return ask_l(li);
		if(p.mid< l) return ask_l(ri);
		return ask_l(li)+ask_l(ri);
	}

	hh ask_r(const int i=1)
	{
		if(bao) return p.hr;
		if(p.mid>=r) return ask_r(li);
		if(p.mid< l) return ask_r(ri);
		return ask_r(ri)+ask_r(li);
	}
}
#define change(cx,ck) xds::l=xds::r=cx,xds::k=ck,xds::change()
inline hh ask_l(const int cl,const int cr) {xds::l=cl,xds::r=cr; return xds::ask_l();}
inline hh ask_r(const int cl,const int cr) {xds::l=cl,xds::r=cr; return xds::ask_r();}
namespace bcj
{
	list<int> z[N];
	int fu[N];
	void lian(int x,int y)
	{
		x=fu[x],y=fu[y];
		if(z[x].size()<z[y].size()) swap(x,y);
		for(const int &i:z[y]) change(i,x),fu[i]=x;
		z[x].splice(z[x].end(),z[y]);
	}
}
#define p2(x) (1<<x)
int l,r,mid;
bool solve(const int a)
{
	if(a-1<=n)
	{
		l=0,r=(a+1)/2;
		while(l+1<r)
		{
			mid=(l+r)>>1;
			if(ask_l(1,mid)==ask_r(a-mid,a-1)) l=mid;
			else r=mid;
		}
		if(l==(a-1)/2) return 0;
		else
		{
			bcj::lian(l+1,a-l-1);
			return 1;
		}
	}
	else
	{
		l=0,r=(n*2-a+1)/2+1;
		while(l+1<r)
		{
			mid=(l+r)>>1;
			if(ask_l(a-n,a-n+mid-1)==ask_r(n-mid+1,n)) l=mid;
			else r=mid;
		}
		if(l==(n*2-a+1)/2) return 0;
		else
		{
			bcj::lian(a-n+l,n-l);
			return 1;
		}
	}

}
int main()
{
	ios_base::sync_with_stdio(false),cin.tie(nullptr),cout.tie(nullptr);
	//freopen("test.in","r",stdin),freopen("qwe.out","w",stdout);
	cin>>n; logn=log2(n);
	mt19937 rng(time(nullptr));
	uniform_int_distribution<ll> r_x(1,M);
	pp[0]=1;
	for(int i=1;i<=n;i++) xx[i]=r_x(rng),bcj::fu[i]=i,pp[i]=pp[i-1]*P;
	for(int i=1;i<=n;i++) bcj::z[i].push_back(i);
	xds::build(1,1,n);
	for(int i=3;i<=n*2-1;i++) cin>>a[i].a,a[i].i=i;
	sort(a+3,a+n*2,[&](const ai &a,const ai &b){return a.a<b.a;});
	for(int i=3;i<=n*2-1;i++)
		while(solve(a[i].i))
			ans+=a[i].a;
	cout<<ans;
	return 0;
}