Codeforces Round #366 (Div. 1) B. Ant Man （贪心）

B. Ant Man

time limit per test

4 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Scott Lang is at war with Darren Cross. There are n chairs in a hall where they are, numbered with 1, 2, ..., n from left to right. The i-th chair is located at coordinate xi. Scott is on chair number s and Cross is on chair number e. Scott can jump to all other chairs (not only neighboring chairs). He wants to start at his position (chair number s), visit each chair exactly once and end up on chair numbere with Cross.

As we all know, Scott can shrink or grow big (grow big only to his normal size), so at any moment of time he can be either small or large (normal). The thing is, he can only shrink or grow big while being on a chair (not in the air while jumping to another chair). Jumping takes time, but shrinking and growing big takes no time. Jumping from chair number i to chair number j takes |xi - xj|seconds. Also, jumping off a chair and landing on a chair takes extra amount of time.

If Scott wants to jump to a chair on his left, he can only be small, and if he wants to jump to a chair on his right he should be large.

Jumping off the i-th chair takes:

• ci extra seconds if he's small.
• di extra seconds otherwise (he's large).

Also, landing on i-th chair takes:

• bi extra seconds if he's small.
• ai extra seconds otherwise (he's large).

In simpler words, jumping from i-th chair to j-th chair takes exactly:

• |xi - xj| + ci + bj seconds if j < i.
• |xi - xj| + di + aj seconds otherwise (j > i).

Given values of x, a, b, c, d find the minimum time Scott can get to Cross, assuming he wants to visit each chair exactly once.

Input

The first line of the input contains three integers n, s and e (2 ≤ n ≤ 5000, 1 ≤ s, e ≤ n, s ≠ e) — the total number of chairs, starting and ending positions of Scott.

The second line contains n integers x1, x2, ..., xn (1 ≤ x1 < x2 < ... < xn ≤ 109).

The third line contains n integers a1, a2, ..., an (1 ≤ a1, a2, ..., an ≤ 109).

The fourth line contains n integers b1, b2, ..., bn (1 ≤ b1, b2, ..., bn ≤ 109).

The fifth line contains n integers c1, c2, ..., cn (1 ≤ c1, c2, ..., cn ≤ 109).

The sixth line contains n integers d1, d2, ..., dn (1 ≤ d1, d2, ..., dn ≤ 109).

Output

Print the minimum amount of time Scott needs to get to the Cross while visiting each chair exactly once.

Example

input

7 4 3
8 11 12 16 17 18 20
17 16 20 2 20 5 13
17 8 8 16 12 15 13
12 4 16 4 15 7 6
8 14 2 11 17 12 8

output

139

Note

In the sample testcase, an optimal solution would be . Spent time would be17 + 24 + 23 + 20 + 33 + 22 = 139.

首先说明一下，这个贪心我证明不出来，出题人也没有证明出来，那为什么能AC，因为对拍不出反例，就这么简单。如果你有证明过程，留言一下。谢谢。

题意：额。。。大概是这样：在一个数轴上有n个点，每个点有5个值x,a,b,c,d，你每次可以从一个点i跳跃到另外一个点j。

如果j在i的右边，则需要花费abs(x[i]-x[j])+c[i]+b[j]。

如果j在i的左边，则需要花费abs(x[i]-x[j])+d[i]+a[j]，

一开始你位于s点，你的目的是遍历所有的点1遍并且最后停在e点，求最小花费.（注意：每个点最多只能遍历1遍）

题解：瞎贪心。

初始化链：next[s] = e表示直接从起点s跳到终点e。

然后枚举其他所有的点，将它们一个一个插入到链中（寻找加入到链中的什么地方花费最低）

例如样例：
①：初始化：4->3
②：插入编号为1的点，显然1只能插入一个地方，插入后：4->1->3
③：插入编号为2的点，2可以插入两个地方（4和1中间或1和3中间），可以轻松算出插入4和1中间成本更低，所以
插入后：4->2->1->3
④：编号为3和4的点是起点和终点，跳过
⑤：插入编号为5的点，5可以插入三个地方，其中插入1和3中间成本更低，插入后：4->2->1->5->3
⑥：插入编号为6的点，……，插入后：4->2->1->6->5->3。

依次类推。

代码：

#pragma comment(linker, "/STACK:102400000,102400000")
//#include<bits/stdc++.h>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<map>
#include<cmath>
#include<queue>
#include<set>
#include<stack>
#include <utility>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define mst(a) memset(a, 0, sizeof(a))
#define M_P(x,y) make_pair(x,y)  
#define rep(i,j,k) for (int i = j; i <= k; i++)  
#define per(i,j,k) for (int i = j; i >= k; i--)  
#define lson x << 1, l, mid  
#define rson x << 1 | 1, mid + 1, r  
const int lowbit(int x) { return x&-x; }  
const double eps = 1e-8;  
const int INF = 1e9+7; 
const ll inf =(1LL<<62) ;
const int MOD = 1e9 + 7;  
const ll mod = (1LL<<32);
const int N = 5010; 
const int M=100010; 
template <class T1, class T2>inline void getmax(T1 &a, T2 b) {if (b>a)a = b;}  
template <class T1, class T2>inline void getmin(T1 &a, T2 b) {if (b<a)a = b;}
int read()
{
	int v = 0, f = 1;
	char c =getchar();
	while( c < 48 || 57 < c ){
		if(c=='-') f = -1;
		c = getchar();
	}
	while(48 <= c && c <= 57) 
		v = v*10+c-48, c = getchar();
	return v*f;
}

ll x[N],a[N],b[N],c[N],d[N],Next[N];
ll cost(int i,int j)
{
	if(i>j)return abs(x[i]-x[j])+c[i]+b[j];
	else return abs(x[i]-x[j])+d[i]+a[j];
}
int main()
{
	#ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif
    int n,s,e;
	n=read();s=read();e=read();
	for(int i=1;i<=n;i++)x[i]=read();
	for(int i=1;i<=n;i++)a[i]=read();
	for(int i=1;i<=n;i++)b[i]=read();
	for(int i=1;i<=n;i++)c[i]=read();
	for(int i=1;i<=n;i++)d[i]=read();
	Next[s]=e;
	ll ans=cost(s,e);
	for(int i=1;i<=n;i++)
	{
		if(i==s || i==e)continue;
		int u=s;
		int v;
		ll Min=1e18;
		while(u!=e)
		{
			ll tmp=cost(u,i)+cost(i,Next[u])-cost(u,Next[u]);
			if(tmp<Min)
			{
				Min=tmp;
				v=u;
			} 
			u=Next[u];
		}
		ans+=Min;
		Next[i]=Next[v];
		Next[v]=i; 
	}
	printf("%I64d\n",ans);
	return 0;
}