jardinero NOIP2013 lo largo de muchos métodos de solución de problemas

Ver el título original Luo Valley ( https://www.luogu.org/problem/show?pid=1970 )
primero Un presentes espaciales en un problema cuando yo estaba haciendo aprendido complejidad es O (1) la solución
es primero utilizar f1, f2 se registran, respectivamente, en dos secuencias diferentes. Es un tipo de bajas lados medio altos y uno de ambos lados de la secuencia intermedia de mayor a menor. F1, F2 de los valores iniciales se establecen en 1 (fácil de demostrar que podemos elegir la primera cuenca 1 como resultado, no se deteriorará # Manual divertido) para grabar en una olla con x, h para grabar la cuenca actual satisfecho sobre varios condiciones :
no hay necesidad de transferencia cuando el X - == 1.h
se pueden transferir 2.h> cuando uno de los ejes X
3.H

#include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;

inline int read(){
    int num;
    char ch;
    while((ch=getchar())<'0' || ch>'9');
    num=ch-'0';
    while((ch=getchar())>='0' && ch<='9'){
        num=num*10+ch-'0';
    }
    return num;
}
inline void out(int x){
    if(x>=10){
        out(x/10);
    }
    putchar(x%10+'0');
}

int main(){
    int n,h,f1,f2,x;
    f1=1,f2=1;
    n=read();
    h=read();
    //scanf("%d%d",&n,&h);
    for(register int i=1;i<n;i++){
        x=h;
        h=read();
        //scanf("%d",&h);
        if(h>x){
            f1=max(f1,f2+1);
        }
        if(h<x){
            f2=max(f2,f1+1);
        }
    }
    out(max(f1,f2));
    //printf("%d",max(f1,f2));
    return 0;
}

A continuación se presenta una solución a un problema con la solución a un problema que se ve DP hacer Sede:
En primer lugar Esta pregunta puede ser generalmente resumirse como sigue: se encontró una secuencia más larga de manera que cualquier elemento intermedio de tres adyacentes de la secuencia que no es el elemento máximo el más pequeño, por lo que ni siquiera pensamos de los más largos sub-secuencia no cae: tales como elementos de D [i] y D [j], se supone que d [i]> d [j ] y j> i, entonces vamos a long_ [j] = max (long_ [j], long_ [i] 1); a continuación, podemos ver una analogía, no deje caer la secuencia más larga antes de que el nodo actual es encontrar un cualificado, entonces Esta pregunta también se puede utilizar como un máximo secuencias no caer, sólo tiene que buscar el alcance del nodo actual es el precursor de un nodo antes, y tenemos que hacer la misma manera que un niño no se levanta secuencia, y, finalmente, tomar el máximo, entonces esta pregunta sería acabada;
publicado un robar código tranquilamente robado:

#include<iostream>
#include<cstdio>
#define II int
#define R register
#define I 123456
using namespace std;

II a[I],d_1[I],d_2[I];

II n;

int main()
{
    scanf("%d",&n);
    R II x;
    for(R II i=1;i<=n;i++) scanf("%d",&x), a[i]=x;
    d_1[1]=d_2[1]=1;
    //d_1[]代表的是当前元素是以当前元素为中心的三个相邻的元素中最大的；
    //同理，d_2[]代表的是当前元素是以当前元素为中心的三个相邻的元素中最小的；
    //但是当前元素不一定选，可能是继承上一个元素的信息；
    for(R II i=2;i<=n;i++)
    {
        if(a[i]>a[i-1]) d_1[i]=max(d_1[i-1],d_2[i-1]+1), d_2[i]=d_2[i-1];
        //如果当前元素大于这个前一个元素；
        //那么当前元素若果选，则是前一个元素作为最低点时的长度+1；
        //如果不选，就继承前一个元素作为最高点，等价于当前元素作为最高点；
        //当前元素作为最低点就只能继承前一个点作为最低点；
            else{
                if(a[i]<a[i-1]) d_1[i]=d_1[i-1], d_2[i]=max(d_1[i-1]+1,d_2[i-1]);
                //如果当前元素小于前一个元素，则道理同上，只是反过来；
                    else d_1[i]=d_1[i-1],   d_2[i]=d_2[i-1];
                    //如果当前元素等于前一个元素，那么这个元素直接继承前一个元素的所有信息；
                    //因为这两个点是完全等价的；
            }
    }
    R II ans=max(d_1[n],d_2[n]);
    //我们在最后时取两种状态的最大值作为答案；
    cout<<ans<<endl;
    return 0;
}

I Código pro-test a 16 ms
luego introducir uno es escribir código codiciosos Orz, una idea breve de la misma:
Vamos a hablar acerca de la avaricia de la prueba:
1. no habrá arbitraria monótonamente creciente o decreciente del intervalo de más de dos cepa fue. Si tres dejado la contradicción. (Esto es similar a la figura su barra de tracción)
2. cualquier no más de n + 1 cepas izquierda dentro del n continua monótonamente creciente o decreciente intervalo.
3. Sólo dos secciones monótonas tomaron cada uno un máximo de plantas, no influirá en la selección de la próxima planta (que puede tardar hasta).
A continuación, se adhieren sobre el código codiciosos:

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100010];
void jyxin(int &x)
{
    char c=getchar();
    x=0;
    while(c>'9'||c<'0')c=getchar();
    while(c>='0'&&c<='9')x=x*10+c-48,c=getchar();
}
int main()
{
    int n,i=2,sum=0;
    jyxin(n);jyxin(a[1]);
    if(n==2)
    {
        jyxin(a[2]);
        if(a[2]==a[1])cout<<1;
        else cout<<2;
    }
    if(n==1)cout<<1;
    jyxin(a[2]);
    while(i<n)
    {
       i++;
       jyxin(a[i]);
       if(a[i]==a[i-1])a[i-1]=a[i-2];
       if((a[i]>a[i-1]&&a[i-2]>a[i-1])||(a[i]<a[i-1]&&a[i-2]<a[i-1]))sum++;
    }
    if(sum==0)
    {
        if(a[n]==a[n-1])cout<<1;
         else cout<<2;
    }
    else cout<<sum+2;
    return 0;    
}

Esta pregunta es probablemente la mejor solución para todos los Orz