hdu6447 YJJ‘s Salesman（排序、BIT优化dp）

题意：

二维平面上有n个点，每个点(x,y)有一个开心值，
当从(x−1,y−1)走到(x,y)时，就能拿到这个点的开心值，
现在从(0,0)出发，每次只能从(x,y)走到(x+1,y),(x,y+1),(x+1,y+1)，
问能获得的总的开心值的最大值。

数据范围：n<=1e5，0<=x,y<=1e9，保证不存在相同的点

解法：

朴素dp:
令d[i][j]为到达(i,j)的最大值
那么d[i][j]=max(d[i-1][j],d[i][j-1],d[i-1][j-1]+val[i][j])

优化:
将点按x从小到大排序,如果x相同,y从大到小排序(等下说为什么从大到小)
按顺序枚举点,d[i]表示对于当前枚举到的点的x,坐标为i时的最大值,
即d[i]表示(x,i)的最大值,
转移方程,设枚举到(x,y,v),那么d[y]=max(d[y],d[k]+v),其中k<=y-1

但是这样可能会想到一个问题:
如果当前x和上一次的x相同,d[k]可能就不能+v了,因为需要满足x,y都严格小于,
注意我们前面的排序方式,x相同的时候,按y从大到小排序,
这样就算上一次的x相同,更新的d[y]也只可能是d[k+1]之后,d[1,k]是不会被影响的

因为纵坐标的范围为1e9,离散化一下变为1e5,
计算d[1,y-1]的最大值套个RMQ数据结构就行了

code：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int maxm=1e5+5;
struct Node{
    int x,y,v;
    bool operator<(const Node &a)const{
        if(x!=a.x)return x<a.x;
        return y>a.y;
    }
}e[maxm];
struct BIT{
    int c[maxm];
    int lowbit(int i){
        return i&-i;
    }
    void add(int i,int t){
        while(i<maxm){
            c[i]=max(c[i],t),i+=lowbit(i);
        }
    }
    int ask(int i){
        int ans=0;
        while(i){
            ans=max(ans,c[i]),i-=lowbit(i);
        }
        return ans;
    }
    void init(){
        memset(c,0,sizeof c);
    }
}t;
int b[maxm];
int d[maxm];
int n;
signed main(){
    ios::sync_with_stdio(0);
    int T;cin>>T;
    while(T--){
        cin>>n;
        for(int i=1;i<=n;i++){
            cin>>e[i].x>>e[i].y>>e[i].v;
            b[i]=e[i].y;
        }
        sort(e+1,e+1+n);
        sort(b+1,b+1+n);
        int num=unique(b+1,b+1+n)-b-1;
        for(int i=1;i<=n;i++){
            e[i].y=lower_bound(b+1,b+1+num,e[i].y)-b;
        }
        for(int i=0;i<num;i++)d[i]=0;
        t.init();
        int ans=0;
        for(int i=1;i<=n;i++){
            int y=e[i].y;
            int ma=t.ask(y-1);
            d[y]=max(d[y],ma+e[i].v);
            ans=max(ans,d[y]);
            t.add(y,d[y]);
        }
        cout<<ans<<endl;
    }
    return 0;
}

---