MM不哭【区间DP】

区间DP的经典题 和关路灯本质上是一样的

题目如下：

描述

在一个数轴上,有n个MM(绝非恐龙!)在哭泣(5555~一直哭).

tcboy也在这个数轴上,并恰好看到了这一幕,由于每个MM哭都会让tcboy损失一定的rp,于是tcboy有必要去安慰她们.(真命苦啊 T.T)

开始时，tcboy站在k号MM的旁边.

现在知道第i个MM哭泣每秒钟会使tcboy降低 w[i]的rp (单位rp/s).

而tcboy的行走速度很慢只有1m/s . 

tcboy安慰MM的方式很特别(怎么安慰随便大家YY了..#@$%^%$#@),不需要花费时间.

请计算tcboy安慰完所有MM,会消耗掉的rp的最小值.

输入格式

输入文件的第一行包含一个整数N，2<=N<=1000，表示MM的数量。
第二行包含一个整数V，1<=V<=N，表示开始时tcboy站在几号MM的旁边.
接下来的N行中，每行包含两个用空格隔开的整数D和W，用来描述每个MM，其中0<=D<=1000，0<=W<=1000。D表示MM在数轴上的位置(单位: m)，W表示每秒钟会使tcboy降低W的rp。

输出格式

输出只有一行：一个整数，即消耗rp之和的最小值。结果不超过1,000,000,000。

测试样例1

输入

4 
3 
2 2 
5 8 
6 1 
8 7

输出

56

题目给的数据应该是有序的 若不放心 可以在读入后排一下序。

排好序后 妹子1....N就等待在各自的物理位置D[i]被我们安慰了 (*^__^*) 嘻嘻……

此时妹子的序号的相对大小可以代表她们之间的相对顺序

首先，每当安慰完[i,j]这个区间的妹子们，当所掉人品最少时，安慰完所有妹子后的最终位置一定在i或j点 且一定不会有任何一个时刻越过区间 因为要越过时一定在区间端点，且妹子一定未被安慰完（一旦安慰完结果就固定了）走出去后还要走回来安慰妹子 白白掉人品 显然不是最优解。

因为最终位置一定是最后一个被安慰的妹子的位置 假设它在x∈(i,j) ,x为整数

因为x是最后一个妹子 所以此时其它妹子已经被安慰完毕，包括i和j妹子 所以我们一定曾经到过i和j点，因为人的步伐是连续的，所以此时[i,j]之间的所有妹子一定都已经被安慰完毕，这与x未被安慰矛盾，所以我们得到最终位置一定在区间端点。

因此 设f[i][j][0]为安慰完从妹子i到妹子j之间的所有的妹子且最终位置在i时所掉的最少人品

      f[i][j][1]为安慰完[i,j]所有妹子后最终停在j点时所掉的最少人品

则安慰完[i,j]的妹子所消耗的最少人品为min(f[i][j][0],f[i][j][1])

因此最终解为 min(f[1][n][0],f[1][n][1])

由初始条件有 f[v][v][0]=f[v][v][1]=0

设W[i]为从1到i妹子的攻击力之和 通过输入时的一个预处理即可实现 

显然 解区间[i,j]一定包含起始点  所以我们只需要讨论包含起始点的区间即可 以起始点区间[v,v]分别向左以变量i  向右以变量j伸展 因为我们是从v点左右伸展的 所以f[i][j][0] 一定是由i+1这一点向左走来的 且最后安慰的一定是妹子i 所以安慰[i,j]的妹子可分为两个阶段 一是安慰完[i+1,j]的妹子 二是安慰i妹子 所以

f[i][j][0]=min(f[i+1][j][0]+(W[i]+(W[N]-W[j]))*(D[i+1]-D[i]),f[i+1][j][1]+(W[i]+(W[N]-W[j]))*(D[j]-D[i]));

同理可得 

f[i][j][1]=min(f[i][j-1][0]+(W[i-1]+(W[N]-W[j-1]))*(D[j]-D[i]),f[i][j-1][1]+(W[i-1]+(W[N]-W[j-1]))*(D[j]-D[j-1]));

从递归方程可以看到 j应该从小到大 i应该从大到小 

若把j放入内层 则初始时对不同的j而言f[i+1][j][0]和f[i+1][j][1]应该全部求解完毕  对不同的i f[i][V]也应该存在

以V为分界点 我们需要求得f[V][,,,,,]([0]、[1])（.....指的是对不同的j）f[....][V]([0]、[1])  (对不同的i)

显然因为本身在V点 而最优解一定是停在最后一个才被安慰的妹子上 显然右端点不能是最优解了

所以f[i][V][0]=f[i+1][V][0]+(W[i]+(W[N]-W[V]))*(D[i+1]-D[i])

而f[i][V][1]一定要安慰i妹子 而安慰完i妹子后一定[i,V]都安慰完了，此时再返回V

分为两部分 则安慰[i,V]的最优方法（一定停在i点） 再加上从i直线走到V是最优方案

所以 f[i][V][1]=f[i][V][0]+(W[i-1]+(W[N]-W[V]))*(D[V]-D[i])   

同理  f[V][j][1]=f[V][j-1][1]+(W[V-1]+(W[N]-W[j-1]))*(D[j]-D[j-1]);
f[V][j][0]=f[V][j][1]+(W[V-1]+(W[N]-W[j]))*(D[j]-D[V]);

所以 代码如下

//MM不哭 区间动归 
#include <cstdio>
#include <cstring> 
#include <iostream>
using namespace std;
int f[1001][1001][2]={0},W[1001]={0},D[1001]={0},N=0,V=0;
int main()
{
	scanf("%d%d",&N,&V);
	for(int i=1;i<=N;i++)
	{
		scanf("%d%d",&D[i],&W[i]);
		W[i]+=W[i-1];
	}
	f[V][V][0]=f[V][V][1]=0;
	for(int i=V-1;i>=1;i--)
	{
		f[i][V][0]=f[i+1][V][0]+(W[i]+(W[N]-W[V]))*(D[i+1]-D[i]);
		f[i][V][1]=f[i][V][0]+(W[i-1]+(W[N]-W[V]))*(D[V]-D[i]);
	}

	for(int j=V+1;j<=N;j++)
	{
		f[V][j][1]=f[V][j-1][1]+(W[V-1]+(W[N]-W[j-1]))*(D[j]-D[j-1]);
		f[V][j][0]=f[V][j][1]+(W[V-1]+(W[N]-W[j]))*(D[j]-D[V]);
	}
	for(int i=V-1;i>=1;i--)
		for(int j=V+1;j<=N;j++)
	{
		f[i][j][0]=min(f[i+1][j][0]+(W[i]+(W[N]-W[j]))*(D[i+1]-D[i]),f[i+1][j][1]+(W[i]+(W[N]-W[j]))*(D[j]-D[i]));
		f[i][j][1]=min(f[i][j-1][0]+(W[i-1]+(W[N]-W[j-1]))*(D[j]-D[i]),f[i][j-1][1]+(W[i-1]+(W[N]-W[j-1]))*(D[j]-D[j-1]));
	}
	printf("%d\n",min(f[1][N][0],f[1][N][1]));
	return 0;
}

对这里的W[i]可以用一个S[i][j]来代替

S[i][j]表示安慰完[i,j]所有妹子后剩余妹子的杀伤力

即S[i][j]=W[i-1]+(W[N]-W[j])

写法如下

for (i=1;i<=N;i++) 
    {
        s[i][i]=W[i];
        t+=s[i][i];
    }
    for (i=1;i<=n;i++)
    {
        s[i][i]=t-s[i][i];
        for (j=i+1;j<=n;j++) 
			s[i][j]=s[i][j-1]-s[j][j];
    }

还有一种递归搜索的写法 如下

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <iostream> 
using namespace std;
void right(int a,int b);
long long f[1001][1001][2]={0};
int D[1001]={0},W[1001]={0},N,V;

void left(int a,int b)
{
	printf("called left(%d,%d)\n",a,b);
	if(a-1>=1&&f[a-1][b][0]>f[a][b][0]+(W[a-1]+(W[N]-W[b]))*(D[a]-D[a-1]))
	{
		f[a-1][b][0]=f[a][b][0]+(W[a-1]+(W[N]-W[b]))*(D[a]-D[a-1]);
		left(a-1,b);
	}
	if(b+1<=N&&f[a][b+1][1]>f[a][b][0]+(W[a-1]+(W[N]-W[b]))*(D[b+1]-D[a]))
	{
		f[a][b+1][1]=f[a][b][0]+(W[a-1]+(W[N]-W[b]))*(D[b+1]-D[a]);
		right(a,b+1);
	}
	return;
	
	
}

void right(int a,int b)
{
	printf("called right(%d,%d)\n",a,b);
	if(a-1>=1&&f[a-1][b][0]>f[a][b][1]+(W[a-1]+(W[N]-W[b]))*(D[b]-D[a-1]))
	{
		f[a-1][b][0]=f[a][b][1]+(W[a-1]+(W[N]-W[b]))*(D[b]-D[a-1]);
		left(a-1,b);
	}
	if(b+1<=N&&f[a][b+1][1]>f[a][b][1]+(W[a-1]+(W[N]-W[b]))*(D[b+1]-D[b]))
	{
		f[a][b+1][1]=f[a][b][1]+(W[a-1]+(W[N]-W[b]))*(D[b+1]-D[b]);
		right(a,b+1);
	}
	return;
}

int main()
{

	scanf("%d%d",&N,&V);
	for(int i=1;i<=N;i++)
	{
		scanf("%d",&D[i]);
		scanf("%d",&W[i]);
	}
    memset(f,1,sizeof(f));
   	for(int i=2;i<=N;i++)
   	{
		W[i]+=W[i-1];
	}
    f[V][V][0]=f[V][V][1]=0;
    left(V,V);
	right(V,V);
	printf("%d\n",min(f[1][N][0],f[1][N][1]));
	return 0;
}