#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5100;
int n, s, e;
const long long inf = 1e18;
int X[MAXN], A[MAXN], B[MAXN], C[MAXN], D[MAXN];
void load() {
  scanf("%d%d%d", &n, &s, &e);
  s--;
  e--;
  for (int i = 0; i < n; i++) scanf("%d", X + i);
  for (int i = 0; i < n; i++) scanf("%d", A + i);
  for (int i = 0; i < n; i++) scanf("%d", B + i);
  for (int i = 0; i < n; i++) scanf("%d", C + i);
  for (int i = 0; i < n; i++) scanf("%d", D + i);
}
long long dp[2][MAXN][2][2];
void minim(long long &a, long long b) { a = min(a, b); }
void solve() {
  for (int i = 0; i < MAXN; i++)
    for (int j = 0; j < 2; j++)
      for (int k = 0; k < 2; k++) dp[1][i][j][k] = inf;
  dp[1][0][0][0] = 0;
  long long sol = inf;
  for (int i = 0; i < n; i++) {
    int d = i % 2;
    for (int j = 0; j < MAXN; j++)
      for (int k = 0; k < 2; k++)
        for (int l = 0; l < 2; l++) dp[d][j][k][l] = inf;
    for (int j = 0; j < (n + 1); j++)
      for (int k = 0; k < 2; k++)
        for (int l = 0; l < 2; l++) {
          if (i != s && i != e) {
            if (j + k + l > 1)
              minim(dp[d][j - 1][k][l],
                    dp[1 - d][j][k][l] + 2LL * X[i] + C[i] + A[i]);
            minim(dp[d][j + 1][k][l],
                  dp[1 - d][j][k][l] - 2LL * X[i] + D[i] + B[i]);
            if (j || k) minim(dp[d][j][k][l], dp[1 - d][j][k][l] + A[i] + D[i]);
            if (j || l) minim(dp[d][j][k][l], dp[1 - d][j][k][l] + B[i] + C[i]);
            if (i == n - 1 && j == 0 && k && l)
              minim(sol, dp[1 - d][j][k][l] + 2LL * X[i] + A[i] + C[i]);
          }
          if (i == s && k == 0) {
            if (j) minim(dp[d][j - 1][1][l], dp[1 - d][j][k][l] + C[i] + X[i]);
            minim(dp[d][j][1][l], dp[1 - d][j][k][l] + D[i] - X[i]);
            if (i == n - 1 && l && j == 0)
              minim(sol, dp[1 - d][j][k][l] + X[i] + C[i]);
          }
          if (i == e && l == 0) {
            minim(dp[d][j][k][1], dp[1 - d][j][k][l] + B[i] - X[i]);
            if (j) minim(dp[d][j - 1][k][1], dp[1 - d][j][k][l] + A[i] + X[i]);
            if (i == n - 1 && k && j == 0)
              minim(sol, dp[1 - d][j][k][l] + A[i] + X[i]);
          }
        }
  }
  printf("%I64d\n", sol);
}
int main() {
  load();
  solve();
  return 0;
}
