[BZOJ2131]免费的馅饼-树状数组优化DP

说在前面

真的…好困啊…！

晚自习时间的日常犯困=A=

题目

BZOJ2131传送门

题意

一个竖直的二维平面里，有宝物不断地从上面掉下来。第i个宝物下降到平面底部的时间为ti，位置为pi，宝物价值为vi。

你作为一个玩家，要在这个竖直平面的底部接住足够的宝物来获取最高的价值。你可以在平面底部移动，并且你的速度最大为：2单位/单位时间。初始时间你可以在平面底部的任意一个位置。

现在给定上述所有信息，需要求出可获得的最大价值。

输入&&输出

第一行输入平面底部宽度W（≤1e8）和宝物个数N（≤1e5）

接下来N行每行三个整数ti,pi,vi，含意同上

输出最大价值

解法

看到W这种范围，大概猜到要么是O(n)题，要么就是和W没什么关系…

然后这是一道DP题【显然】

定义dp[i][j]表示第i个物品落下时，在j位置可获得最大价值。

很容易看出来

dp[i][j]=max(dp[i−1][k])+v[i] ( |j−k|≤2∗Δt )

然后发现第一维可以不要，存坐标就可以了，每次可以在原来的基础上更新。

但是这个更新条件很奇怪，带有绝对值，于是咱们把绝对值拆开，然后再移项。对于两个物品i,j来说（假设i在j之后落下），如果j可以转移到i，则有{2∗t[j]+pos[j]≤2∗t[i]+pos[i]2∗t[j]−pos[j]≤2∗t[i]−pos[i]

可以发现，每个物品相当于有两个值。j的两个值都小于i时就可以转移。

把其中的某一个权值排序，然后用树状数组（或者线段树）维护另一个权值就好了（这里需要离散化）。

每次转移都是前缀最大值进行转移。

所以这题和那个1e8的W并没有丝毫的关系。dp[i]也不是代表的在某位置的最优解了，而是某个值(2*t-p或者2*t+p)的最优解。

自带大常数的代码

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

int W , N , uninum ;
struct Data{
int t , p , v ;//a = 2 * t + p ; sort by a
int a , b ;    //b = 2 * t - p ; query by b
bool operator < ( const Data &A ) const {
return a < A.a ;
}
}o[100005] ;
struct Unique_Data{
int b , id ; //b = 2 * t - p ;
bool operator < ( const Unique_Data &A ) const {
return b < A.b ;
}
}uni[100005] ;

class BIT{
public :
void updata( int x , int delta ){
for( ; x <= uninum ; x += x&-x )
num[x] = max( num[x] , delta ) ;
}
int Query( int x ){
int rt = 0 ;
for( ; x ; x -= x&-x ) rt = max( rt , num[x] ) ;
return rt ;
}
void init(){
memset( num , 0 , sizeof( num ) ) ;
}
private :
int num[100005] ;
}B;

void Unique_(){
sort( uni + 1 , uni + N + 1 ) ;
uni[0].b = -2147483647 ;
for( int i = 1 ; i <= N ; i ++ ){
if( uni[i].b != uni[i-1].b ) uninum ++ ;
o[ uni[i].id ].b = uninum ;
}
}

void solve(){
sort( o + 1 , o + N + 1 ) ; B.init() ;
for( int i = 1 ; i <= N ; i ++ )
B.updata( o[i].b , B.Query( o[i].b ) + o[i].v ) ;
printf( "%d" , B.Query( uninum ) ) ;
}

int main(){
scanf( "%d%d" , &W , &N ) ;
for( int i = 1 ; i <= N ; i ++ ){
scanf( "%d%d%d" , &o[i].t , &o[i].p , &o[i].v ) ;
o[i].a = 2 * o[i].t + o[i].p ;
uni[i].b = 2 * o[i].t - o[i].p ;
uni[i].id = i ;
}
Unique_() ;
solve() ;
}