BZOJ3315: [Usaco2013 Nov]Pogo-Cow

3315: [Usaco2013 Nov]Pogo-Cow

Time Limit: 3 Sec  Memory Limit: 128 MB
Submit: 143  Solved: 79
[Submit][Status]

Description

In an ill-conceived attempt to enhance the mobility of his prize cow Bessie, Farmer John has attached a pogo stick to each of Bessie's legs. Bessie can now hop around quickly throughout the farm, but she has not yet learned how to slow down. To help train Bessie to hop with greater control, Farmer John sets up a practice course for her along a straight one-dimensional path across his farm. At various distinct positions on the path, he places N targets on which Bessie should try to land (1 <= N <= 1000). Target i is located at position x(i), and is worth p(i) points if Bessie lands on it. Bessie starts at the location of any target of her choosing and is allowed to move in only one direction, hopping from target to target. Each hop must cover at least as much distance as the previous hop, and must land on a target. Bessie receives credit for every target she touches (including the initial target on which she starts). Please compute the maximum number of points she can obtain.

一个坐标轴有N个点，每跳到一个点会获得该点的分数，并只能朝同一个方向跳，但是每一次的跳跃的距离必须不小于前一次的跳跃距离，起始点任选，求能获得的最大分数。

Input

* Line 1: The integer N.

* Lines 2..1+N: Line i+1 contains x(i) and p(i), each an integer in the range 0..1,000,000.

Output

* Line 1: The maximum number of points Bessie can receive.

Sample Input

6
5 6
1 1
10 5
7 6
4 8
8 10

INPUT DETAILS: There are 6 targets. The first is at position x=5 and is worth 6 points, and so on.

Sample Output

25
OUTPUT DETAILS: Bessie hops from position x=4 (8 points) to position x=5 (6 points) to position x=7 (6 points) to position x=10 (5 points).

从坐标为4的点，跳到坐标为5的，再到坐标为7和，再到坐标为10的。

HINT

 

Source

Silver

题解：

n^3的dp很好想，我们想一下如何把时间压缩成 n^2

n^3时间主要花费在寻找合法的下一个节点上，这样做了很多无用功

比如说  我们现在已经知道  i->j 之后 能到 k，那么 i->j 之后也一定能到k+1

所以我们用 f[j][i]来更新它能更新到的节点，

显然如果 s[k]-s[j]>=s[j]-s[i] 那么能转移到 k 的状态应该是 max(f[j][i],f[j][i+1],.......f[j][j])

而s[k]是递增的，也就是说能更新到 k，那么一定能更新到 k+1以及n。

所以我们维护一个区域最大值，枚举 j的前一个节点 i，tmp记录 f[j][i]..f[j][j]的最大值

然后 k 是一个递增的，这样每个节点的转移是可以做到O(n)的，整个算法的复杂度就是O(n^2)

注意还要倒着做一遍

说不太清楚，看代码更简单？有点儿单调队列的感觉？

代码：

 #include<cstdio>
 #include<cstdlib>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 #include<iostream>
 #include<vector>
 #include<map>
 #include<set>
 #include<queue>
 #include<string>
 #define inf 1000000000
 #define maxn 1500
 #define maxm 500+100
 #define eps 1e-10
 #define ll long long
 #define pa pair<int,int>
 #define for0(i,n) for(int i=0;i<=(n);i++)
 #define for1(i,n) for(int i=1;i<=(n);i++)
 #define for2(i,x,y) for(int i=(x);i<=(y);i++)
 #define for3(i,x,y) for(int i=(x);i>=(y);i--)
 #define mod 1000000007
 using namespace std;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<=''){x=*x+ch-'';ch=getchar();}
     return x*f;
 }
 int n,ans=,f[maxn][maxn];
 struct rec{int x,y;}a[maxn];
 inline bool cmp(rec a,rec b)
 {
     return a.x<b.x;
 }
 int main()
 {
     freopen("input.txt","r",stdin);
     freopen("output.txt","w",stdout);
     n=read();
     for1(i,n)a[i].x=read(),a[i].y=read();
     sort(a+,a+n+,cmp);
     a[].x=-inf;
     for1(i,n)
      {
          f[i][i]=a[i].y;
          int k=i+,tmp=f[i][i];
          for3(j,i-,)
           {
               while(k<=n&&a[k].x-a[i].x<a[i].x-a[j].x)
                {
                    f[k][i]=max(f[k][i],tmp+a[k].y);
                    //cout<<k<<' '<<i<<' '<<f[k][i]<<endl;
                    ans=max(ans,f[k][i]);
                    k++;
                }
               tmp=max(tmp,f[i][j]);
               if(k>n)break;
          }
     }
     //for1(i,n)for1(j,i-1)cout<<i<<' '<<j<<' '<<f[i][j]<<endl;
     memset(f,,sizeof(f));
     a[n+].x=inf;
     for3(i,n,)
      {
          f[i][i]=a[i].y;
          int k=i-,tmp=f[i][i];
          for2(j,i+,n+)
           {
               while(k&&a[i].x-a[k].x<a[j].x-a[i].x)
                {
                    f[k][i]=max(f[k][i],tmp+a[k].y);
                    //cout<<k<<' '<<i<<' '<<tmp<<' '<<f[k][i]<<endl;
                    ans=max(ans,f[k][i]);
                    k--;
                }
               tmp=max(tmp,f[i][j]);
               if(!k)break;
          }
      }
     printf("%d\n",ans);
     return ;
 }