ZOJ 3469 Food Delivery(区间DP)

题目链接：

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4255

题目大意：

在一条直线上，有一些需要送饭的顾客。每个客户有一个位置以及不满意度，他们的不满意度会随着时间的增加而增加。现在要送餐给所有的客户，要求能够使得送完以后顾客的不满意度最小。

思路：

区间DP。

这题我们首先要考虑送餐的方式。对于某一个顾客i来说，如果餐厅在i的左侧，那么要送到i的过程中，一定会沿途将那些顾客都送好。

也就是说，如果我要访问i,j的区间，那么在[i,j]里面的顾客也一定都已经被访问过了。

而去送餐的方式就只有两种，往左或者往右。所以我们可以设dp[i][j][k]，k=0或者1，表示在i~j区间里面都访问过以后最后停留在i处或者是j处的最小不满意度。

这里0代表最后停留在左边，1代表最后停留在右边。

那么dp[i][j][0]就可以由dp[i+1][j][0]和dp[i+1][j][1]得到。

dp[i][j][1]就可以由dp[i][j-1][0]和dp[i][j-1][1]得到。

具体状态转移方程在代码里面，搞清楚以后还是不难理解的。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int min(int a,int b)
{
    return a<b?a:b;
}
 int dp[1005][1005][2],sum[1005];
 struct node{
  int x,b;
 }p[1005];
 bool cmp(node a,node b)
 {
     return a.x<b.x;
 }
int main()
{
    int N,V,X,i,j,k,d,K;
    while(scanf("%d%d%d",&N,&V,&K)!=EOF)
    {
        memset(sum,0,sizeof(sum));
        memset(p,0,sizeof(p));
        for(i=1;i<=N;i++)
            scanf("%d%d",&p[i].x,&p[i].b);
            N++;
            p[N].x=K;
            p[N].b=0;
            sort(p+1,p+1+N,cmp);
            for(i=0;i<1005;i++)
            for(j=0;j<1005;j++)
                for(k=0;k<=1;k++)
            {
                dp[i][j][k]=1<<31-1;
             
            }
            int temp;
            for(i=1;i<=N;i++)
            {
                sum[i]=sum[i-1]+p[i].b;    //sum[i]表示前i个顾客的不满意度。
                if(p[i].x==K)temp=i;
            }
            dp[temp][temp][0]=dp[temp][temp][1]=0;
           for(i=temp;i>=1;i--)
            for(j=temp;j<=N;j++)
           {
               if(i==j)continue;

               dp[i][j][0]=min(dp[i][j][0],dp[i+1][j][0]+(p[i+1].x-p[i].x)*(sum[N]+sum[i]-sum[j]));    //这里要考虑到其他还在等的顾客的不满意度。
               dp[i][j][0]=min(dp[i][j][0],dp[i+1][j][1]+(p[j].x-p[i].x)*(sum[N]+sum[i]-sum[j]));
               dp[i][j][1]=min(dp[i][j][1],dp[i][j-1][1]+(p[j].x-p[j-1].x)*(sum[N]-sum[j-1]+sum[i-1]));
               dp[i][j][1]=min(dp[i][j][1],dp[i][j-1][0]+(p[j].x-p[i].x)*(sum[N]-sum[j-1]+sum[i-1]));
           }
           printf("%d\n",min(dp[1][N][0],dp[1][N][1])*V);
    }
    return 0;
}