#include <bits/stdc++.h>
using namespace std;
template <typename T>
void Minimize(T& x, T y) {
  x = min(x, y);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  int n, firstPosition, lastPosition;
  cin >> n >> firstPosition >> lastPosition;
  vector<int> x(n + 1);
  for (int i = 1; i <= n; ++i) {
    cin >> x[i];
  }
  vector<vector<int>> a(4, vector<int>(n + 1));
  for (int id = 0; id < 4; ++id) {
    for (int i = 1; i <= n; ++i) {
      cin >> a[id][i];
    }
  }
  vector<vector<long long>> dp(n + 2, vector<long long>(n + 1, LLONG_MAX));
  if (1 == firstPosition) {
    dp[2][1] = a[3][1];
  } else if (1 == lastPosition) {
    dp[2][1] = a[1][1];
  } else {
    dp[2][1] = a[1][1] + a[3][1];
  }
  for (int i = 2; i <= n; ++i) {
    int delta = x[i] - x[i - 1];
    for (int components = 1; components < i; ++components) {
      if (dp[i][components] == LLONG_MAX) {
        continue;
      }
      int totalBorders =
          components * 2 - (i > firstPosition) - (i > lastPosition);
      if (i == firstPosition) {
        Minimize(dp[i + 1][components],
                 dp[i][components] + 1LL * totalBorders * delta + a[2][i]);
        Minimize(dp[i + 1][components + 1],
                 dp[i][components] + 1LL * totalBorders * delta + a[3][i]);
      } else if (i == lastPosition) {
        Minimize(dp[i + 1][components],
                 dp[i][components] + 1LL * totalBorders * delta + a[0][i]);
        Minimize(dp[i + 1][components + 1],
                 dp[i][components] + 1LL * totalBorders * delta + a[1][i]);
      } else {
        int validPositions = components - 1;
        if (validPositions >= 1) {
          Minimize(dp[i + 1][components - 1], dp[i][components] +
                                                  1LL * totalBorders * delta +
                                                  a[0][i] + a[2][i]);
        }
        validPositions =
            (components + 1) - (i > firstPosition) - (i > lastPosition);
        if (validPositions >= 1) {
          Minimize(dp[i + 1][components + 1], dp[i][components] +
                                                  1LL * totalBorders * delta +
                                                  a[1][i] + a[3][i]);
        }
        validPositions = components - (i > firstPosition);
        if (validPositions >= 1) {
          Minimize(dp[i + 1][components], dp[i][components] +
                                              1LL * totalBorders * delta +
                                              a[1][i] + a[2][i]);
        }
        validPositions = components - (i > lastPosition);
        if (validPositions >= 1) {
          Minimize(dp[i + 1][components], dp[i][components] +
                                              1LL * totalBorders * delta +
                                              a[0][i] + a[3][i]);
        }
      }
    }
  }
  cout << dp[n + 1][1];
  return 0;
}
