#include<bits/stdc++.h>
using namespace std;
int mian(); int main() { return mian(); }

#define ll long long
#define ull unsigned ll
const int N = 2e5 + 25;
int n, a[N << 1], _;

int id[N << 1];

const ull base = 1e9 + 9;
ull pw[N];
void init_pw() {
	pw[0] = 1; for(int i = 1; i <= n; ++i) pw[i] = pw[i - 1] * base;
	//初始化不要写错
}

struct UF {
	int fa[N];
	vector<int> mbs[N];
	void init() { for(int i = 1; i <= n; ++i) fa[i] = i, mbs[i].push_back(i); }
	int get(const int x) { if(x == fa[x]) return x;; return fa[x] = get(fa[x]); }
	int us(int u, int v) {
		u = get(u); v = get(v);
		if(u == v) return 0;
		if((int)mbs[u].size() < (int)mbs[v].size()) swap(u, v);
		for(auto vp : mbs[v]) mbs[u].push_back(vp);//不要写成 v
		fa[v] = u;
		return v;
	}
}uf;

#define lson (k << 1)
#define rson (k << 1 | 1)
#define mid ((l + r) >> 1)
ull t1[N << 2], t2[N << 2];
void updata(const int k, const int l, const int r) {
	t1[k] = pw[r - mid] * t1[lson] + t1[rson];
	t2[k] = t2[lson] + pw[mid - l + 1] * t2[rson];
}
void build(const int k, const int l, const int r) {
	if(l == r) return t1[k] = t2[k] = l, void();
	build(lson, l, mid); build(rson, mid + 1, r);
	updata(k, l, r);
}
void change(const int k, const int l, const int r, const int x) {
	if(l == r) return t1[k] = t2[k] = uf.get(l), void();
	if(x <= mid) change(lson, l, mid, x);
	else change(rson, mid + 1, r, x);
	updata(k, l, r);
}
ull ask1(const int k, const int l, const int r, const int x, const int y) {
	// ull ans = 0;
	// for(int i = x; i <= y; ++i) ans = ans * base + uf.get(i);
	// return ans;
	if(x <= l and r <= y) return t1[k];
	if(x > mid) return ask1(rson, mid + 1, r, x, y);
	if(y <= mid) return ask1(lson, l, mid, x, y);
	return pw[min(r, y) - mid] * ask1(lson, l, mid, x, y) + ask1(rson, mid + 1, r, x, y);
}
ull ask2(const int k, const int l, const int r, const int x, const int y) {
	// ull ans = 0;
	// for(int i = y; i >= x; --i) ans = ans * base + uf.get(i);
	// return ans;
	if(x <= l and r <= y) return t2[k];
	if(x > mid) return ask2(rson, mid + 1, r, x, y);
	if(y <= mid) return ask2(lson, l, mid, x, y);
	return ask2(lson, l, mid, x, y) + ask2(rson, mid + 1, r, x, y) * pw[mid - max(x, l) + 1];
}
#undef lson
#undef rson
#undef mid

ll ans;
int ceii(const int x, const int y) {
	if(x % y == 0) return x / y;;
	return x / y + 1;
}
void solve(const int u) {
	int Ll = max(1, u - n), Lr = (u - 1) >> 1, Rl = ceii(u + 1, 2), Rr = min(n, u - 1);
	while( ask1(1, 1, n, Ll, Lr) != ask2(1, 1, n, Rl, Rr) ) {
		// int l1 = Ll, r1 = Lr, l2 = Rl, r2 = Rr, ans1 = 0, ans2 = 0;
		// while(l1 <= r1) {
		// 	// if(ask1(1, 1, n, l1, r1) == ask2(1, 1, n, l2, r2)) break;
		// 	const int mid1 = (l1 + r1) >> 1, mid2 = ceii(l2 + r2, 2);
		// 	if( ask1(1, 1, n, Ll, mid1) != ask2(1, 1, n, mid2, Rr) ) ans1 = mid1, ans2 = mid2, r1 = mid1 - 1, l2 = mid2 + 1;
		// 	else l1 = mid1 + 1, r2 = mid2 - 1;
		// }
		// const int out = uf.us(ans1, ans2);
		// assert(out);
		// assert(ans1 + ans2 == u and ans1 and ans2);
		int l = Ll, r = Lr, ant = 0;
		while(l <= r) {
			const int mid = (l + r) >> 1;
			// cout<<Ll<<" "<<mid<<"  "<<u - mid<<" "<<Rr<<endl;
			if(ask1(1, 1, n, Ll, mid) != ask2(1, 1, n, u - mid, Rr)) ant = mid, r = mid - 1;
			else l = mid + 1;
		}
		const int out = uf.us(ant, u - ant);
		// cout<<ans<<" "<<u - ans<<" "<<out<<endl;
		// cout<<ask1(1, 1, n, 1, 1)<<" "<<ask2(1, 1, n, 3, 3)<<endl;
		assert(ant and out);
		ans += a[u];
		// for(int i = 1; i <= n; ++i) cout<<uf.get(i)<<" ";; puts("");
		for(auto xf : uf.mbs[out]) change(1, 1, n, xf);
	}
}
int mian() {
	_ = scanf("%d", &n);
	for(int i = 3; i < (n << 1); ++i) _ = scanf("%d", &a[i]), id[i] = i;
	sort(id + 3, id + (n << 1), [](const int A, const int B){ return a[A] < a[B]; });
	init_pw(); uf.init(); build(1, 1, n);
	for(int i = 3; i < (n << 1); ++i) solve(id[i]);
	printf("%lld\n", ans);
	return 0;
}/*
给定一个 $n$ 个点的完全图，两个点 $i,j$ 的边权为 $a_{i+j}$，求最小生成树的边权和
$2\le n\le 2\times 10^5, 1\le a_i\le 10^9$
$1s, 1G$

不好用 bru 实现，所以考虑 kruskal
从大到小枚举所有的边权，假设当前是 $a_u$
那么就是要快速判断每一对 $i+j=u$ 是否不再同一个连通块中
不妨假设 $i\lt j$，那么就有 $i\le \frac{u-1}{2},j\lt u$
此时会发现如果一个 $i,j$ 在同一个连通块内，那么会关于中间的地方对称
那么人、如果将一个点的权值设置为他的连通块，相当于判断回文
于是用字符串 hash 的形式判断回文，对于每两个位置，如果他们不合法，那么每一次用二分找到第一个不在连通块内的并把他们合并
合并的时候可以用启发式合并，因为会涉及到修改每一个位置。
那么他因为有修改，所以也就是线段树维护。因为至多会进行 $n-1$ 次二分操作，且启发式合并，所以时间复杂度为 $O(n\log^2 n)$
*/