「BZOJ1537」Aut – The Bus（变形Dp+线段树/树状数组 最优值维护）

　　 网格图给予我的第一反应就是一个状态 f[i][j] 表示走到第 (i,j) 这个位置的最大价值。

　　由于只能往下或往右走转移就变得显然了：

　　　　f[i][j]=max{f[i-1][j], f[i][j-1]}+a[i][j]

　　但是面对庞大的数据范围，再优秀的电脑也无法驾驭 百亿亿 的时间复杂度，与 百亿亿 的空间复杂度。

　　其实只要稍加思考我们就可以发现，枚举那些没有价值的 (x,y) 的坐标是多余的，所以我们只需要枚举有价值的点，在进行Dp转移就会起到加速。

　　因此新的状态即为：f[i] 表示到达第 i 个点的最大价值（Ps：为了避免后效性应先把一维的坐标进行排序，原因即是当前的状态只可能从最近的上一次转移而来），所以转移即为：

　　　　f[i]=max{f[j]}+a[i] ( 0<j≤i-1，x[j]≤x[i]，y[j]≤y[i] )

　　虽然此时它优秀了不少，但是面对 1≤ n ≤10^9 数据范围，它还是离 AC 此题相隔甚远QAQ。

　　所以对于现在的转移，i 的枚举无法避免，但是对于 MAX 的最优求解仍有极大的优化空间。所以此时我们面临的问题是： f[j] 的转移状态能否从一些连续的数值范围内得到呢，其实仔细思考一下就可以得到一个规律，对于一个 f[i] 它的坐标 (x[i], y[i]) ，假设我们将 x[i] 进行了排序，显然仍以的 x[i] 都满足转移的条件，所以我们转移只可能来自 1 ˜ y[i]-1 这个范围内，所以只要快速求得1 ˜ y[i]-1 内的转移的最大值，就可解决此题！

　　显然我们可以维护一个线段树，来维护前 k 种 y[i] 的转移的最大值（由于它是再求前缀的最优值，我们也可以用树状数组来维护）。

　　在维护时，我们可以通过 二分查找 快速求得当前的 y[i] 位于第几小的纵向坐标，再根据一种优秀的数据结构来解决最优值的维护。

　　所以再最后献上本人的专属代码（线段树版本）与网络大佬的代码（树状数组版本）：

　　

 首先是蒟蒻本人的专属代码：

 #include<bits/stdc++.h>
 using namespace std;
 const int MAXN_TREE=;
 const int MAXN=;

 inline int read(){
     int ret=;
     char ch=getchar();
     while (ch<'' || ch>'') ch=getchar();
     while (ch>='' && ch<='') ret=ret*+ch-'', ch=getchar();
     return ret;
 }
 // 读入优化

 struct You{
     int x, y, val;
 }a[MAXN];
 int b[MAXN], tree[MAXN_TREE], Ans, n;

 inline bool cmp(const You&x, const You&y){
     return x.x<y.x || (x.x==y.x && x.y<y.y);
 }

 inline int find(int x){
     int l=,r=n;
     while(l<=r){
         int mid=(l+r)>>;
         if(b[mid]<x)l=mid+;
             else if(b[mid]==x)return mid;
                 else r=mid-;
     }
 }
 // 二分查找

 inline int query(int root, int l, int r, int x, int y){
     if (y<l || x>r) return ;
     if (l>=x && r<=y) return tree[root];
     int mid=(l+r)>>;
     return max(query(root+root, l, mid, x, y), query(root+root+, mid+, r, x, y));
 }
 // 线段树区间查找

 inline void change(int root, int l, int r, int x, int sum){
     if (r<x || l>x) return;
     if (l==r && l==x){
         tree[root]=sum;
         return;
     }
     int mid=(l+r)>>;
     change(root+root, l, mid, x, sum);
     change(root+root+, mid+, r, x, sum);
     tree[root]=max(tree[root+root], tree[root+root+]);
 }
 //线段树单点修改

 int main(){
     n=read(), n=read(), n=read();
     for (int i=; i<=n; i++) a[i].x=read(), a[i].y=read(), a[i].val=read(), b[i]=a[i].y;
     sort(a+, a++n, cmp);
     sort(b+, b++n);
     for (int i=; i<=n; i++){
         int Place=find(a[i].y);                  // 寻找当前 y[i] 为第Place小的横向坐标
         int Sum=a[i].val+query(, , n, , Place);
         change(, , n, Place, Sum);        //插入当前转移的值
         Ans=max(Ans, Sum);
     }
     printf("%d\n", Ans);
     return ;
 }

大佬的代码，来自与http://hzwer.com/3248.html/
未经允许复制下来，希望大佬不要追究法律责任QWQ，所以我就不做详细
介绍了：

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
inline int read()
{
    int x=;char ch=getchar();
    while(ch<''||ch>'')ch=getchar();
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x;
}
int n,ans;
int t[],hash[];
struct data{int x,y,p;}a[];
inline bool cmp(data a,data b)
{if(a.x==b.x)return a.y<b.y;return a.x<b.x;}
int find(int x)
{
    int l=,r=n;
    while(l<=r)
    {
        int mid=(l+r)>>;
        if(hash[mid]<x)l=mid+;
        else if(hash[mid]==x)return mid;
        else r=mid-;
    }
}
inline int lowbit(int x){return x&(-x);}
void change(int x,int val)
{
     for(int i=x;i<=n;i+=lowbit(i))
         t[i]=max(val,t[i]);
}
int ask(int x)
{
    int tmp=;
    for(int i=x;i>;i-=lowbit(i))
         tmp=max(tmp,t[i]);
    return tmp;
}
int main()
{
    n=read(),n=read(),n=read();
    for(int i=;i<=n;i++)
    {
        a[i].x=read();a[i].y=read();a[i].p=read();
        hash[i]=a[i].y;
    }
    sort(hash+,hash+n+);
    sort(a+,a+n+,cmp);
    int tmp,pos;
    for(int i=;i<=n;i++)
    {
        pos=find(a[i].y);
        tmp=a[i].p+ask(pos);
        change(pos,tmp);
        ans=max(ans,tmp);
    }
    printf("%d",ans);
    return ;
}

太优美了，蒟蒻在线膜拜！！！

第二篇加油加油，奋斗ing！！！QAQ