#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<vector>
#include<stack>
#include<queue>
#include<deque>
#include<map>
#include<set>
#include<limits>
#include<climits>
#include<cmath>
#include<functional>
#include<ctime>
#include<cstdlib>
#include<fstream>
#include<typeinfo>

using namespace std;

typedef long long int ll;
typedef short int i16;
typedef unsigned long long int u64;
typedef unsigned int u32;
typedef unsigned short int u16;
typedef unsigned char u8;

const int N = 150100;

const int N3 = N*3;

const int INF = 1000000000;

struct edge
{
    int to,w;
    edge(){}
    edge(int a, int b)
    {
        to=a;
        w=b;
    }
};

struct el
{
    int vertex,cost;
    el(){}
    el(int a, int b)
    {
        vertex=a;
        cost=b;
    }
    bool operator<(const el &a) const
    {
        return cost>a.cost;
    }
};

int a[4][N];

int n;

vector <edge> v[N3];

int dist[N3];

priority_queue <el> q;

void input() //Correct!
{
    scanf("%d", &n);
    int i,j;
    for(i=1;i<=3;i++)
    {
        for(j=1;j<=n;j++)
        {
            scanf("%d", &a[i][j]);
        }
    }
}

void swap_rows(int r1, int r2) //Correct!
{
    int i;
    for(i=1;i<=n;i++)
    {
        swap(a[r1][i],a[r2][i]);
    }
}

void build_graph()
{
    int i,j;
    for(i=0;i<N3;i++)
        v[i].clear();
    v[0].push_back(edge(1,a[1][1]));
    for(i=1;i<n;i++)
    {
        v[i].push_back(edge(i+1,a[1][i+1]));
        v[i].push_back(edge(n+i+1,a[2][i+1]));
    }
    for(i=1;i<n;i++)
    {
        v[i+n].push_back(edge(i+n+1,a[2][i+1]));
        v[i+n].push_back(edge(i+n*2+1,a[3][i+1]));
    }
    for(i=1;i<n;i++)
    {
        v[i+n*2].push_back(edge(i+n*2+1,a[3][i+1]));
    }
}

int Dijkstra()
{
    int i;
    for(i=1;i<N3;i++)
    {
        dist[i]=INF;
    }
    dist[0]=0;
    q.push(el(0,0));
    el curr;
    int current_distance;
    while(!q.empty())
    {
        curr=q.top();
        q.pop();
        for(i=0;i<v[curr.vertex].size();i++)
        {
            current_distance=v[curr.vertex][i].w+curr.cost;
            if(current_distance<dist[v[curr.vertex][i].to])
            {
                dist[v[curr.vertex][i].to]=current_distance;
                q.push(el(v[curr.vertex][i].to,current_distance));
            }
        }
    }
    return dist[n*3];
}

void solve()
{
    int ans=INF;
    build_graph();
    ans=min(ans,Dijkstra());
    swap_rows(2,3);
    build_graph();
    ans=min(ans,Dijkstra());
    swap_rows(2,3);

    swap_rows(1,2);
    build_graph();
    ans=min(ans,Dijkstra());
    swap_rows(2,3);
    build_graph();
    ans=min(ans,Dijkstra());
    swap_rows(2,3);
    swap_rows(1,2);

    swap_rows(1,3);
    build_graph();
    ans=min(ans,Dijkstra());
    swap_rows(2,3);
    build_graph();
    ans=min(ans,Dijkstra());
    swap_rows(2,3);
    swap_rows(1,3);

    printf("%d\n", ans);
}


int main()
{
    input();
    solve();
    return 0;
}