wyh的问题

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while (sc.hasNext()){
            int N=sc.nextInt();
            int V=sc.nextInt();
            int D[]=new int[N+1];
            int W[]=new int[N+1];
            for(int i=1;i<=N;i++){
                D[i]=sc.nextInt();
                W[i]=sc.nextInt();
                W[i]+=W[i-1];
            }
            //定义dp[i][j][2],看成二维dp表，一个单元格存两个数，就好理解。
            //将数组分为三部分，最中间的是处理过的，那么肯定右两个指针分割它们，那么，dp[i][j]的意义为
            //已经处理过的部分[i,j]，消耗的最小能源值是多少
            //每次去往下一个地方，就是i和j向左右扩展，并且工作人员当前要嘛在i处，要吗在j处
            //每次去往下一个地方花的时间算出来，乘以[1,i-1]以及[i+1,N]上的功率总和。就是浪费的时间
            //W[i]就是用来加速求一个段上的总和的，比如总和[1,i]就是W[i]，总和[i+1,N],就是W[N]-W[i]
            //dp[][][0]的意思是，当前位置在左边的状态，同理dp[][][1]表示当前位置在右边的状态
            //显然，最开始的时候当前位置即可以看作在左边，也可以看作在右边，那么的dp[V][V][0]=dp[V][V][1]=0
            //最终结束的位置是dp[1][N]
            long dp[][][]=new long[N+1][N+1][2];
            //画表后得知，三个条件，i<=V,j>=V,且i<j,可知只需对右上角的小正方形做dp即可（其左底角位置为[V][V]）
            //状态依赖为dp[i][j]依赖dp[i+1][j]和dp[i][j-1]。具体看dp主体。可知每个单元格依赖它下面的和左边的，即从下到上，从左往右dp即可。
            //那么，需要填写base case，即第V行的前V个，和第V列的前V个

            //第V列 从下往上时，dp只依赖于它下面的，根据意义可知，它下面的单元格j是固定为V的，回归到题意，说明一次也不能往右移动，每次都只能往左移动
            //所以dp[i][V][0]是如何求的，很容易理解
            //而dp[i][V][1]怎么求呢，很简单，dp[i][V][0]变为dp[i][V][1],意思就是从这头跑到那头，不关任何灯
            for(int i=V-1;i>0;i--){
                dp[i][V][0]=dp[i+1][V][0]+(D[i+1]-D[i])*(W[i]+W[N]-W[V]);
                dp[i][V][1]=dp[i][V][0]+(D[V]-D[i])*(W[i-1]+W[N]-W[V]);
            }
            //同理求dp[V][i]..
            for(int i=V+1;i<=N;i++){
                dp[V][i][1]=dp[V][i-1][1]+(D[i]-D[i-1])*(W[V-1]+W[N]-W[i-1]);
                dp[V][i][0]=dp[V][i][1]+(D[i]-D[V])*(W[V-1]+W[N]-W[i]);
            }
            //写不写都行，dp[V][V][0]=dp[V][V][1]=0;
            for(int i=V-1;i>0;i--){
                for(int j=V+1;j<=N;j++){
                    dp[i][j][0]=Math.min(dp[i+1][j][1]+(D[j]-D[i])*(W[i]+W[N]-W[j]),dp[i+1][j][0]+(D[i+1]-D[i])*(W[i]+W[N]-W[j]));
                    dp[i][j][1]=Math.min(dp[i][j-1][0]+(D[j]-D[i])*(W[i-1]+W[N]-W[j-1]),dp[i][j-1][1]+(D[j]-D[j-1])*(W[i-1]+W[N]-W[j-1]));
                }
            }
            System.out.println(Math.min(dp[1][N][0],dp[1][N][1]));
        }
    }

}