[单调队列] UVA 10534 Wavio Sequence

单调队列，Staginner的分析；

关键在于正确性和最优性的证明：

正确性：通过单调队列的维护，不会得到比实际最长串更大的长度；

最优性：通过单调队列的维护，能得到不小于最长串的长度；

　　实际存在的最长串在出现之后，单调队列的长度不会小于这个最长串的长度（替换不改变长度，只有进队时增加了长度），而之前出现的较大的队列尾会被替换，较小的会被较大的通过入队的方式更新。

/*
    UVA 10534 - Wavio Sequence
*/
# include <cstring>
# include <cstdio>

# define N 10000 + 5

int n;
int a[N];
int f[N], g[N];

int max(int x, int y)
{
    return x>y ? x:y;
}

int min(int x, int y)
{
    return x<y ? x:y;
}

void init(void)
{
    for (int i = 1; i <= n; ++i)
        scanf("%d", &a[i]);
}

int bin_search(int *v, int key, int n)
{
    int high = n, low = 1, mid;
    while (low < high)
    {
        mid = low + ((high-low)>>1);
        if (v[mid] < key) low = mid+1;
        else if (v[mid] == key) return mid;
        else high = mid;
    }
    return low;
}

void compute(int *d, int inc, int ss, int tt)
{
    int s[N], top = 0;
    for (int i = ss; i != tt; i += inc)
    {
        int &t = a[i];
        if (t>s[top]) s[++top] = t;
        else
        {
            int k = bin_search(s, t, top);
            s[k] = t;
        }
        d[i] = top;
    }
}

void solve(void)
{
    compute(f, 1, 1, n);
    compute(g, -1, n, 1);
    int ans = 0, tmp;
    for (int i = 1; i <= n; ++i)
    {
        int tmp = min(f[i], g[i]);
        if (ans < tmp) ans = tmp;
    }
    printf("%d\n", ans*2-1);
}

int main()
{
    while (~scanf("%d", &n))
    {
        init();
        solve();
    }
    
    return 0;
}

直接DP复杂度为O（n^2），单调队列的方式为O(n*logn)；

由于单调队列的维护方法，不能得到最长子列，而只能得到其长度。