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  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随机生成，所有随机数服从某区间内的均匀分布。

解一

动态规划

运用如下状态转移方程

1、令S[i][1]表示以i为结尾，且降序到达a[i]的最长抖动序列长度；令S[i][0]表示以i为结尾，且升序到达a[i]的最长抖动序列长度。则有如下递推公式：

S[i+1][1]=max(S[j][0])+1,i>=j>=1,a[j]>a[i+1],

S[i+1][0]=max(S[j][1])+1,i>=j>=1,a[j]

S[1][1]=S[1][0]=1。

则最终答案应该是max(S[n][1],S[n][0])。

进一步有优化得：

（1）h[i+1]>ha[i]:

S[i+1,0]=max(S[i,1]+1，S[i,0]);

S[i+1,1]=S[i,1];

（2）h[i+1]

S[i+1,0]=S[i,0];

S[i+1,1]=max(S[i,0]+1,S[i,1]);

（3）h[i+1]=h[i]:

S[i+1,0]=S[i,0];

S[i+1,1]=S[i,1];

S[1,0]=S[1,1]=1.

转移方程也可做如下分析：

• 一看这种数据规模，至多是O(nlog2n)的算法。本题又和序列有关，所以要考虑如何用dp的方法解这道题。 
  用h[i]表示第i株花的高度。 
  仔细分析，发现本题的条件A和条件B在m>1时绝对不能同时满足，而且一个合法的序列必定是一个波动序列。我们用f[i][0]表示第i株花作为序列终点且这株花满足条件A时的最多剩下的株数，f[i][1]表示第i株花作为序列终点且这株花满足条件B时的最多剩下的株数，可以得到： 
  f[i][0]=max{f[j][1]}+1,1≤j<i且h[j]<h[i]; 
  f[i][1]=max{f[j][0]}+1,1≤j<i且h[j]>h[i]; 
  答案ans=max{f[i][0],f[i][1]},1≤i≤n; 
  边界为f[1][0]=f[1][1]=1。 
  这样我们就得到了一个O(n2)的算法，但这并不能满足要求。

• 继续分析，受到求序列连续和的启发，我们可以这样设计状态： 

• 令f[i][0]表示前i株花中的最后一株(不一定是i)满足条件A时的最多剩下的株数，f[i][1]表示前i株花作为序列终点且最后一株(不一定是i)满足条件B时的最多剩下的株数，可以得到： 
  h[i]>h[i−1]时， 
  f[i][0]=max{f[i−1][0],f[i−1][1]+1},f[i][1]=f[i−1][1]; 
  h[i]==h[i−1]时， 
  f[i][0]=f[i−1][0],f[i][1]=f[i−1][1]; 
  h[i]<h[i−1]时， 
  f[i][0]=f[i−1][0],f[i][1]=max{f[i−1][1],f[i−1][0]+1}. 
  答案ans=max{f[n][0],f[n][1]}; 
  边界为f[1][0]=f[1][1]=1

• 
  

代码：

program flower_1;

var

  i,n:longint;{n为开始时花的株数}

 h:array[0..100010]of longint;{h[i]为开始时第i株花的高度}

 s:array[0..100010,-1..2]of longint;{}

function max(p,q:longint):longint;

begin

  assign(input,’flower.in’);

  reset(input);

  assign(output,’flower.out’);

  rewrite(output);

  if p>q thenmax:=p

  else max:=q;

end;{此函数可求两数中的最大数}

begin

  readln(n);//输入株数

  for i:=1 to ndo

    read(h[i]);//输入每株花的高度

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  s[1,0]:=1;

  s[1,1]:=1;

  for i:=2 to ndo

    begin

          if h[i]>h[i-1]

             then

                 begin

                       s[i,0]:=max(s[i-1,1]+1,s[i-1,0]);

                      s[i,1]:=s[i-1,1];

                   end

{ h[i+1]>h[i]:

S[i+1，0]=max(S[i，1]+1，S[i，0]);

S[i+1，1]=S[i，1];}     

else

                   ifh[i]

                      then

                         begin

                             s[i,1]:=max(s[i-1,0]+1,s[i-1,1]);

                             s[i,0]:=s[i-1,0];

                         end

{h[i+1]

S[i+1，0]=S[i，0];

S[i+1，1]=max(S[i，0]+1,S[i，1]);}

                      else

                         begin

                            s[i,0]:=s[i-1,0];

                            s[i,1]:=s[i-1,1];

                         end;

{ h[i+1]=[i]:

S[i+1，0]=S[i，0];        

S[i+1，1]=S[i，1];

S[1，0]=S[1，1]=1.}

end;

  writeln(max(s[n,1],s[n,0]));//输出最大剩余株数

  close(input);

  close(output);{关闭输入输出文件}

end.

解二：

初始化ans=1（保留第一个数据），因为连续单调的一段数据中最多只能保留一个，所以从第2个数据起如果一直单调则一直扫，直到出现拐点则ans+1，然后继续向后扫，循环往复直至扫完，最后输出ans。
注意：此处的单调并非指严格单调，出现相邻数据相同的情况也算单调。序列缩点，连续递减的点和连续递增的点是可以缩到一个代表性的点上的，比如说样例给的5 3 2 1 2，
可以缩成5,1,2或3,1,2或2,1,2，即5 3 2这三个连续递减的点实际上可以由一个点代替，1是一个转折点，
于是你也可以说是找转折点个数。
当找到转折点的个数后 后面必然有成立的点。用转折点的个数 加上后面成立的点的个数 加上必然有一个点满足条件(题目中有说过)就可以在O(n）的时间内找出答案。

代码二：

program flower_2;

var

 n,h1,i,i1,ans:longint;

 h:array[0..100010]of longint; 

begin

  assign(input,’flower.in’);

  reset(input);

  assign(output,’flower.out’);

  rewrite(output);

  readln(n);

 read(h[1]);

 i1:=1;

 for i:=2 to n do

   begin

      read(h1);

if h1<>h[i1]

then

begin

i1:=i1+1;

h[i1]:=h1;

end;

    end;

 if i1=1

    then

      writeln(1)

    else

      begin

        ans:=2;

        for i:=2 to n-1 do

          begin

if ((h[i-1]h[i+1])) or((h[i-1]>h[i]) and (h[i]

then

inc(ans);

end;

writeln(ans);

      end;

  close(input);

  close(output);

end.

代码三：

program flower3;

var

  n,i,ans1,ans2:longint;

  a:array[1..100000]of longint;

functionchaxun(k:integer):longint;      

var

  ans,x:longint;

begin

  x:=a[1];ans:=1;

  for i:=2 to n do

    begin

      if k=-1 then                    //k=-1是该下降了

        if a[i]

          begin                      个高度’然后更新k （k=1 该上升了）可以

            x:=a[i];                   留下的花盆数加1

            k:=1;

            inc(ans);

          end

        else                        //如果这一个比上一个高，把这个高度放入‘上

          begin                       个高度’继续下一次循环（可能出现‘4 2 3’

            x:=a[i];                     的情况 所以需要更新x）

            //continue;

          end

      else                        //如果现在该上升了

        if a[i]>x then              //如果这个比上个高（即可以上升），更新x、k、

          begin                           ans

            x:=a[i];

            k:=-1;

            inc(ans);

          end

        else                      //如果这个比上个低（不能上升），更新x（可能

          begin                      有‘4 2 3’）

            x:=a[i];

            //dec(ans);

          end;

      end;

  chaxun:=ans;

end;

begin

  {assign(input,'flower.in');

  assign(output,'flower.out');

  reset(input);

  rewrite(output);}

  readln(n);                            //读入总花数

  for i:=1 to n do read(a[i]);               //读入各个高度

  ans1:=chaxun(1);                 //第二个比第一个高的情况（即条件A）

  ans2:=chaxun(-1);                 //第二个比第一个低的情况（即条件B）

  if ans1

  writeln(ans1);

  {close(input);

  close(output); }

end.