using System;
using static System.Console;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static int NN => int.Parse(ReadLine());
    static int[] NList => ReadLine().Split().Select(int.Parse).ToArray();
    static int[][] NArr(long n) => Enumerable.Repeat(0, (int)n).Select(_ => NList).ToArray();
    public static void Main()
    {
        Solve();
    }
    static void Solve()
    {
        var c = NList;
        var (n, s) = (c[0], c[1]);
        var x = NList;
        var w = NList;
        var list = new List<(int id, int pos, int w)>(n + 1) { (-1, s, 0 ) };
        for (var i = 0; i < n; ++i) list.Add((i, x[i], w[i]));
        list.Sort((l, r) => l.pos.CompareTo(r.pos));
        var start = 0;
        for (var i = 0; i < list.Count; ++i) if (list[i].id < 0)
        {
            start = i;
            break;
        }
        var cum = new int[list.Count + 1];
        for (var i = 0; i < list.Count; ++i) cum[i + 1] = cum[i] + list[i].w;
        var pos = new int[list.Count];
        for (var i = 0; i < list.Count; ++i) pos[i] = list[i].pos;
        var dp1 = new long[n + 1][];
        var dp2 = new long[n + 1][];
        for (var i = 0; i <= n; ++i)
        {
            dp1[i] = new long[n + 1];
            dp2[i] = new long[n + 1];
            for (var j = 0; j <= n; ++j)
            {
                dp1[i][j] = INF;
                dp2[i][j] = INF;
            }
        }
        DFS(start, 0, n, true, dp1, dp2, cum, pos);
        DFS(start, 0, n, false, dp1, dp2, cum, pos);
        WriteLine(Math.Min(dp1[0][n], dp2[0][n]));
    }
    static long INF = long.MaxValue / 2;
    static void DFS(int s, int l, int r, bool isleft, long[][] dp1, long[][] dp2, int[] cum, int[] pos)
    {
        if (r < s || s < l) return;
        if (isleft)
        {
            if (l == r)
            {
                if (s == l) dp1[l][r] = 0;
                return;
            }
            if (dp1[l][r] < INF) return;
            long weight = cum[^1] - cum[r + 1] + cum[l + 1];
            DFS(s, l + 1, r, true, dp1, dp2, cum, pos);
            DFS(s, l + 1, r, false, dp1, dp2, cum, pos);
            dp1[l][r] = Math.Min(dp1[l][r], dp1[l + 1][r] + weight * (pos[l + 1] - pos[l]));
            dp1[l][r] = Math.Min(dp1[l][r], dp2[l + 1][r] + weight * (pos[r] - pos[l]));
        }
        else
        {
            if (l == r)
            {
                if (s == l) dp2[l][r] = 0;
                else dp2[l][r] = INF;
                return;
            }
            if (dp2[l][r] < INF) return;
            long weight = cum[^1] - cum[r] + cum[l];
            DFS(s, l, r - 1, true, dp1, dp2, cum, pos);
            DFS(s, l, r - 1, false, dp1, dp2, cum, pos);
            dp2[l][r] = Math.Min(dp2[l][r], dp1[l][r - 1] + weight * (pos[r] - pos[l]));
            dp2[l][r] = Math.Min(dp2[l][r], dp2[l][r - 1] + weight * (pos[r] - pos[r - 1]));
        }
    }
}