T2960 全民健身【思维Dp，预处理，差分优化】
Online Judge：YCJSOI
Label：Dp，思维题，预处理，滚动优化
题目描述
乐乐现在掌管一个大公司，办公楼共有n层。为了增加员工的身体素质，他决定在每层楼都建立一个活动室，活动室分乒乓球和排球两种。
已知每层楼喜欢乒乓球和排球的人数。
每个人的行走楼层数是他去自己喜欢的运动室的楼层数。
请你帮乐乐算算，每层楼应该建乒乓球还是排球，使得所有人行走楼层数总和最小。
输入
第一行一个整数n，表示楼层数量。
接下来n行 ，每行两个整数a和b，表示喜欢乒乓球和排球的人数。
输出
输出一个整数，表示所有人行走楼层总和的最小值。
样例
Input#1
2
10 5
4 3
Output#1
9
Input#2
15
68 42
1 35
25 70
59 79
65 63
46 6
28 82
92 62
43 96
37 28
5 92
54 3
83 93
17 22
96 19
Output#2
506
Hint
第一层建乒乓球室，第二层建排球室。行走楼层为5+4=9
对于30%的数据，n的范围\([2,20]\);;
对于80%的数据，n的范围\([2,500]\);
对于100%的数据，n的范围\([2,4000]\)，每层楼喜欢乒乓球和排球的人数范围\([1,10^5]\)。
题解
看数据范围应该是个Dp。
Ⅰ状态定义
一开始看题，不难定义出这样一个状态\(dp[co=0/1][i][j]\)，意义是，已经决策完了前i层建什么，且\([j+1,i]\)这些层建的都是\(co\)，也就是\(j\)这一层建的是\(co\)^\(1\)，此时的最小代价。
但有一个问题，\([j+1,i]\)这些层喜欢\(co\)^\(1\)的人，他们一定是去\(j\)这层吗?不一定，可能还可以去i后面的某点，所以我们无法在当前状态中得知那个最小代价，我们能求得的只有\([1,j]\)这些层所有人的代价+\([j+1,i]\)这些层中喜欢\(co\)的人的代价(为0)。
说人话就是，如果我在\([j+1,i]\)这些层都建乒乓球室，1.那么\([j+1,i]\)这些层中打乒乓球的人都不用移动在本层打就好了(代价为0)，2.在\([1,j]\)这些层的人不论他喜欢乒乓球还是排球都可以在i之前做出决策，3.在\([j+1,i]\)这些层中喜欢排球的人无法在当前层状态中做出决策，因为他们可以选择去第\(j\)层打排球，但如果楼上还有更近的排球管呢？我们在当前状态中无法预知。
所以改一下意义，它表示的是[1,j]这些层所有人的代价+[j+1,i]这些层中喜欢co的人的代价。
Ⅱ转移
初始化如下
memset(dp,-1,sizeof(dp));//相当于赋一个极大值
dp[0][1][0]=dp[1][1][0]=0;
转移采用填表方式，更新最小值。
for(i=1;i<n;++i)for(j=0;j<i;++j)for(x=0;x<=1;++x)if(~dp[x][i][j]){
//枚举当前层i，[j+1,i]都建x
for(y=0;y<=1;++y){//枚举第i+1层建什么
if(x==y)Do(dp[y][i+1][j],dp[x][i][j]);//如果建的和i相同
else{
ll val=calc(y,j+1,i);
if(~val)Do(dp[y][i+1][i],dp[x][i][j]+val);
}
}
}
主要看到\(x!=y\)时的情况，我们此时在中间\([j+1,i]\)建了\(x\)，在两端\(j,i+1\)建了\(y(!x)\)，那个\(calc(co,l,r)\)函数，求的就是\([l,r]\)这些层中喜欢\(co\)的人，分别去到\(l-1，r+1\)的最小代价。
很明显以中点为边界，左半边的去\(l-1\)，右半边的去\(r+1\)最优吧。
最low的求法应该就是下面这种\(O(N)\)的：
虽然非常暴力，但一定要注意下面几处特判。
inline ll calc(int co,int l,int r){
ll sum=0;
register int i,mid=(l+r)>>1;
if(l==1&&r==n)return 1e9;//左右都不能去
if(l==1){//左边不能去
for(i=l;i<=r;++i)sum+=(r-i+1)*a[co][i];
return sum;
}
if(r==n){//右边不能去
for(i=l;i<=r;i++)sum+=(i-l+1)*a[co][i];
return sum;
}
for(i=l;i<=mid;++i)sum+=(i-l+1)*a[co][i];//左半边的去l-1层
for(i=mid+1;i<=r;++i)sum+=(r-i+1)*a[co][i];//右半边的去r+1层
return sum;
}
最后的统计答案如下。别忘了还要加上最后一段代价。
for(x=0;x<=1;++x)for(j=1;j<n;++j){
if(~dp[x][n][j])Do(ans,dp[x][n][j]+calc(x^1,j+1,n));
}
这样，大致的算法流程就结束了。但是也许在上面代码中你就发现了，空间、时间对于100%数据都承受不了（时间复杂度为\(O(4\cdot N^3)\)），只能过掉80%数据。
Ⅲ优化·空间
空间的话，主要是原来的\(dp[2][N][N]\)数组内存好像有点玄，所以求稳优化一波。由于每个\(i\)只用到上一层状态，所以直接滚动就好了，变成dp[2][2][N]。
Ⅲ优化·时间
时间呢，感觉那个calc(co,l,r)函数非常可优化的样子。在草稿纸上列了一下，发现可以利用差分思想，\(O(N)\)预处理前缀/后缀，然后\(O(1)\)计算出结果。
举个例子：对于求\([l,r]\)到它\(l-1\)的代价
比如\(l=4,r=7\)的情况：
列式为\(cost=a[4]*1+a[5]*2+a[6]*3+a[7]*4\)。
我们预处理一个前缀值：isum[i]=\((a[1]*1+a[2]*2+a[3]*3+..a[i]*i)\)；
然后再处理一个普通的前缀和：s[i]=(a[1]+a[2]+a[3]+..a[i])；
那么上式\(cost=isum[7]-(s[7]-s[3])*3\)。
推广一下可以得到：
inline ll getL(int co,int l,int r){//求[l,r]这些层中喜欢co的人跑到第l-1层的代价
ll sum=0;
sum=(isum[0][co][r]-isum[0][co][l-1])-1ll*(l-1)*(s[co][r]-s[co][l-1]);
return sum;
}
类似的，去右端的情况，预处理一个后缀值即可，下面不再赘述。
综上，时间复杂度为\(O(N^2)\)。
完整代码如下：
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=4002;
ll ans=-1;
int a[2][N],n;
inline int read(){
int x=0;char c=getchar();
while(c<'0'||c>'9')c=getchar();
while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
return x;
}
inline void Do(ll &x,ll y){if(x==-1||x>y)x=y;}
ll s[2][N],isum[2][2][N];//isum:sum of i*val
void pre(){
for(int i=1;i<=n;i++){
for(int x=0;x<=1;x++){
s[x][i]=s[x][i-1]+a[x][i];
isum[0][x][i]=isum[0][x][i-1]+1ll*a[x][i]*i;
}
}
for(int i=n;i>=1;i--){
for(int x=0;x<=1;x++){
isum[1][x][i]=isum[1][x][i+1]+1ll*a[x][i]*(n-i+1);
}
}
}
inline ll getL(int co,int l,int r){
ll sum=0;
sum=(isum[0][co][r]-isum[0][co][l-1])-1ll*(l-1)*(s[co][r]-s[co][l-1]);
return sum;
}
inline ll getR(int co,int l,int r){
ll sum=0;int id=n-r;
sum=(isum[1][co][l]-isum[1][co][r+1])-1ll*id*(s[co][r]-s[co][l-1]);
return sum;
}
inline ll calc(int co,int l,int r){//[l,r]可以去l-1,r+1
register int i,mid=(l+r)>>1;
if(l==1&&r==n)return -1;
if(l==1)return getR(co,l,r);
if(r==n)return getL(co,l,r);
return getL(co,l,mid)+getR(co,mid+1,r);
}
ll dp[2][2][N];
namespace p100{
void solve(){
pre();
memset(dp,-1,sizeof(dp));
register int i,j,x,y,g=0;
memset(dp[g],-1,sizeof(dp[g]));
dp[0][g][0]=dp[1][g][0]=0;
for(i=1;i<n;++i){
g^=1;
memset(dp[0][g],-1,sizeof(dp[0][g]));
memset(dp[1][g],-1,sizeof(dp[1][g]));
for(j=0;j<i;++j)for(x=0;x<=1;++x)if(~dp[x][g^1][j]){
for(y=0;y<=1;++y){
if(x==y)Do(dp[y][g][j],dp[x][g^1][j]);
else{
ll val=calc(y,j+1,i);
if(~val)Do(dp[y][g][i],dp[x][g^1][j]+val);
}
}
}
}
for(x=0;x<=1;++x)for(j=1;j<n;++j){
if(~dp[x][g][j])Do(ans,dp[x][g][j]+calc(x^1,j+1,n));
}
printf("%lld\n",ans);
}
}
int main(){
n=read();
for(int i=1;i<=n;++i)a[0][i]=read(),a[1][i]=read();
p100::solve();
}
upd:由于上面代码比较丑，所以在博客文件里还放了几位学长的解析。
