主要是动态规划难

import java.util.*;

public class Main {
    static class meiz {
        int w, v; 
    }
    static int n, s, sloc, st; // 定义静态变量n, s, sloc, st
    static meiz[] a = new meiz[1002]; // 定义meiz类型的数组a
    static long[][][] f = new long[1002][1002][2]; // 定义三维数组f
    static int[] sum = new int[1002]; // 定义数组sum

    public static void main(String[] args) {
        init(); // 调用初始化方法
        dp(); // 调用动态规划方法
    }
    // 初始化方法
    static void init() {
        Scanner scanner = new Scanner(System.in); 
        n = scanner.nextInt(); // 读取整数n
        s = scanner.nextInt(); // 读取整数s
        for (int i = 1; i <= n; i++) { // 循环读取n个meiz的属性
            a[i] = new meiz();
            a[i].w = scanner.nextInt(); // 读取位置信息
            a[i].v = scanner.nextInt(); // 读取rp损失信息
            if (i == s) sloc = a[i].w; // 如果i等于s，则记录当前位置
        }
        Arrays.sort(a, 1, n + 1, (i, j) -> Integer.compare(i.w, j.w)); // 对a数组按位置信息进行排序
        for (int i = 1; i <= n; i++) { // 计算每个位置前的rp损失总和
            sum[i] = sum[i - 1] + a[i].v;
            if (a[i].w == sloc) st = i; // 如果位置等于当前位置，则记录索引
        }
    }

    // 动态规划方法
    static void dp() {
        // 初始化数组f的值
        for (int i = 1; i <= n; i++) {
            for (int j = i; j <= n; j++) {
                f[i][j][0] = f[i][j][1] = (long) 1e15;
            }
        }
        f[st][st][0] = f[st][st][1] = 0; // 初始化当前位置的rp损失为0
        for (int j = 1; j < n; j++) {
            for (int i = 1; i + j <= n; i++) {
                int l = i, r = i + j;
                // 根据位置计算损失的最小值
                f[l][r][0] = Math.min(f[l][r][0], f[l + 1][r][0] + (long) (a[l + 1].w - a[l].w) * (sum[l] + sum[n] - sum[r]));
                f[l][r][0] = Math.min(f[l][r][0], f[l + 1][r][1] + (long) (a[r].w - a[l].w) * (sum[l] + sum[n] - sum[r]));
                f[l][r][1] = Math.min(f[l][r][1], f[l][r - 1][1] + (long) (a[r].w - a[r - 1].w) * (sum[l - 1] + sum[n] - sum[r - 1]));
                f[l][r][1] = Math.min(f[l][r][1], f[l][r - 1][0] + (long) (a[r].w - a[l].w) * (sum[l - 1] + sum[n] - sum[r - 1]));
            }
        }
        long ans = Math.min(f[1][n][0], f[1][n][1]); // 取损失的最小值
        System.out.println(ans); // 输出结果
    }
}