NOIP2013 花匠

2．花匠

(flower.cpp/c/pas)

【问题描述】

花匠栋栋种了一排花，每株花都有自己的高度。花儿越长越大，也越来越挤。栋栋决定把这排中的一部分花移走，将剩下的留在原地，使得剩下的花能有空间长大，同时，栋栋希望剩下的花排列得比较别致。

具体而言，栋栋的花的高度可以看成一列整数ℎ1, ℎ2, … , ℎn。设当一部分花被移走后，剩下的花的高度依次为g₁, g₂, … , g_m，则栋栋希望下面两个条件中至少有一个满足：

条件 A：对于所有的1≤i≤，有g_2i  > g_2i-1，同时对于所有的1≤i≤，有g_2i  > g_2i+1；

条件 B：对于所有的1≤i≤，有g_2i  < g_2i-1，同时对于所有的1≤i≤，有g_2i  < g_2i+1。

注意上面两个条件在 m = 1时同时满足，当 m > 1时最多有一个能满足。

请问，栋栋最多能将多少株花留在原地。

【输入】

输入文件为 flower.in。

输入的第一行包含一个整数，表示开始时花的株数。

第二行包含个整数，依次为ℎ1, ℎ2, … , ℎn，表示每株花的高度。

【输出】

输出文件为 flower.out。

输出一行，包含一个整数，表示最多能留在原地的花的株数。

【输入输出样例】

flower.in	flower.out
5 5 3 2 1 2	3

【输入输出样例说明】

有多种方法可以正好保留 3 株花，例如，留下第 1、4、5 株，高度分别为 5、1、2，满足条件 B。

【数据范围】

对于 20%的数据，n ≤ 10；

对于 30%的数据，n ≤ 25；

对于 70%的数据，n ≤ 1000，0 ≤ ℎn≤ 1000；

对于 100%的数据，1 ≤ n ≤ 100,000，0 ≤ ℎn≤ 1,000,000，所有的ℎn随机生成，所有随机数服从某区间内的均匀分布。

【思路】

  DP

  O(n^2)的方法：

   D[i][s]表示以i为终点且目前是波动序列的s状态的最大株树。

   D[i][s]=max{d[j][!s]+1 (s==0&&A[j]>A[i]) ||(s==1&&A[j]<A[i])}

  O(nlogn)的方法：

   BIT加速状态转移。

  O(n)的方法：

   定义d[i][s]为到i为止目前是波动序列s状态的最大株树。所以d[i][]只用从d[i-1][]转移，详见代码。

   可见动态规划对于状态的定义不同时间性上也会产生差异。

【代码O(n^2)】

#include<iostream>
using namespace std;

const int maxn = 100000+10;

int n;
int d[maxn][2],A[maxn]; 

int main() {
    ios::sync_with_stdio(false);
    cin>>n;
    for(int i=0;i<n;i++) cin>>A[i];
    
    int ans=-(1<<30);
    d[0][1]=d[0][0]=1;
    for(int i=1;i<n;i++)
     for(int s=0;s<2;s++) {
         d[i][s]=1;
         //注意需要把判断{}起来 否则if 的else 就近判断 
         if(s==0) {
             for(int j=0;j<i;j++)  if(A[j]>A[i]) d[i][s]=max(d[i][s],d[j][!s]+1);
         }
         else {
             for(int j=0;j<i;j++) if(A[j]<A[i]) d[i][s]=max(d[i][s],d[j][!s]+1);
         }
         ans=max(ans,d[i][s]); //从所有状态中比较得值 
     }
    cout<<ans; 
    return 0;
}

【代码O(n)】

#include<iostream>
using namespace std;

const int maxn = 100000+10;

int n;
int d[maxn][2],A[maxn]; 

int main() {
  ios::sync_with_stdio(false); 
  cin>>n;
  for(int i=0;i<n;i++) cin>>A[i];
  d[0][0]=d[0][1]=1;
  for(int i=1;i<n;i++) {
      d[i][0]=d[i][1]=1;
      if(A[i]>A[i-1]) {  //判断与前一个点的关系 
          d[i][1]=max(d[i][1],d[i-1][0]+1);
          d[i][0]=d[i-1][0];
      }
      else if(A[i]<A[i-1]) {
          d[i][0]=max(d[i][0],d[i-1][1]+1);
          d[i][1]=d[i-1][1];
      }
      else {
          d[i][0]=d[i-1][0];
          d[i][1]=d[i-1][1];
       }
  }
  cout<<max(d[n-1][0],d[n-1][1]);
  return 0;
}