题目大意：

一条直线的街道上， 在x位置有一家餐厅。

现在街上有 N 个客户同时点餐，每个客户都有一个不开心的值的增加速度。

每一分钟未到，就会增加v。

现在要使所有客户的不开心值最小。

思路分析：

开始想的应该是贪心的。先送完一边再去送完另外一边。

但是如果每边都有一个点离餐厅的距离非常大。但是其他的距离都很小。那么此时的最优就是先送完两边小的。

所以

dp[i] [j] [0] 表示送完了 [i - j] , 人留在 i 位置此时的全局最小不满值。

dp[i] [j] [1] 表示---------------------------j 位置-----------------------------。

每种状态都可以通过四种状态转移过来

也就是dp[i+1][j][0] dp[i+1][j][1] dp[i][j-1][0], dp[i][j-1][1]...

然后自己推导一下增加了的烦恼值。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

struct node
{
    int x,b;
    bool operator < (const node &cmp)const
    {
        return x<cmp.x;
    }
}p[1005];
int dp[1005][1005][2];
int sum[1005];

int query(int l,int r)
{
    if(l>r)return 0;
    return sum[r]-sum[l-1];
}
int main()
{
    int n,v,x;
    while(scanf("%d%d%d",&n,&v,&x)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%d%d",&p[i].x,&p[i].b);
        p[n+1].x=x,p[n+1].b=0;

        sort(p+1,p+2+n);

        memset(dp,0x3f,sizeof dp);

        sum[0]=0;
        for(int i=1;i<=n+1;i++)sum[i]=sum[i-1]+p[i].b;

        int res;
        for(int i=1;i<=n+1;i++)
        {
            if(p[i].x==x)
            {
                res=i;
                break;
            }
        }
        dp[res][res][0]=dp[res][res][1]=0;

        for(int i=res;i>=1;i--)
        {
            for(int j=res;j<=n+1;j++)
            {
                if(i==j)continue;
                int rest = query(1,i)+query(j+1,n+1);
                dp[i][j][0] = min(dp[i][j][0],min(dp[i+1][j][0]+(p[i+1].x-p[i].x)*rest,dp[i+1][j][1]+(p[j].x-p[i].x)*rest));
                dp[i][j][1] = min(dp[i][j][1],min(dp[i+1][j][0]+(p[j].x-p[i].x)*(rest-p[i].b)+(p[i+1].x-p[i].x)*rest,dp[i+1][j][1]+rest*(p[j].x-p[i].x)+(rest-p[i].b)*(p[j].x-p[i].x)));

                rest = query(1,i-1) + query(j,n+1);
                dp[i][j][0] = min(dp[i][j][0],min(dp[i][j-1][0]+rest*(p[j].x-p[i].x)+(rest-p[j].b)*(p[j].x-p[i].x),dp[i][j-1][1]+rest*(p[j].x-p[j-1].x)+(rest-p[j].b)*(p[j].x-p[i].x)));
                dp[i][j][1] = min(dp[i][j][1],min(dp[i][j-1][0]+rest*(p[j].x-p[i].x),dp[i][j-1][1]+(p[j].x-p[j-1].x)*rest));
            }
        }

        printf("%d\n",v*min(dp[1][n+1][0],dp[1][n+1][1]));
    }
    return 0;
}