csu 1551(线段树+DP)

1551: Longest Increasing Subsequence Again

Time Limit: 2 Sec  Memory Limit: 256 MB
Submit: 267  Solved: 112
[Submit][Status][Web Board]

Description

Give
you a numeric sequence. If you can demolish arbitrary amount of
numbers, what is the length of the longest increasing sequence, which is
made up of consecutive numbers? It sounds like
Longest Increasing Subsequence at first sight. So, there is another
limitation: the numbers you deleted must be consecutive.

Input

There are several test cases.
For each test case, the first line of input contains the length of
sequence N(1≤N≤10^4). The second line contains the elements of
sequence——N positive integers not larger than 10^4.

Output

For each the case,
output one integer per line, denoting the length of the longest
increasing sequence of consecutive numbers, which is achievable by
demolishing some(may be zero) consecutive numbers.

Sample Input

7
1 7 3 5 9 4 8
6
2 3 100 4 4 5

Sample Output

4
4
 
题意:给出一个序列，删除任意一段连续的数（也可以不删除），删完后最长严格递增子段（序列必须是连续的）最长。
题解:对付这种题的能力不行啊,看了题解做的.
分析:dp[i][0]代表未删除时以i结尾最长连续上升子序列长度,
dp[i][1]代表删除时以i结尾最长连续上升子序列长度
不删除时很好处理,递推过去就好了,所以可以预处理 dp[i][0]
dp[i][1]可以从dp[i][0]转移过来
1.dp[i][1] = dp[i-1][1]+1 (a[i]>a[i-1])
2.dp[i][1] = dp[j][0]+1 (a[i]>a[j]&&i>j) 这里找dp[j][0]可以利用线段树维护.
这里的更新过程和查询与此题有异曲同工之妙 http://www.cnblogs.com/liyinggang/p/5656485.html

/**分析:dp[i][0]代表未删除时以i结尾最长连续上升子序列长度,
dp[i][1]代表删除时以i结尾最长连续上升子序列长度
不删除时很好处理,递推过去就好了,所以可以预处理 dp[i][0]
dp[i][1]可以从dp[i][0]转移过来
1.dp[i][1] = dp[i-1][1]+1 (a[i]>a[i-1])
2.dp[i][1] = dp[j][0]+1 (a[i]>a[j]&&i>j)
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define N 10005
int dp[N][],a[N],b[N];
int tree[N<<],MAX;
void pushup(int idx)
{
    tree[idx] = max(tree[idx<<],tree[idx<<|]);
}
void build(int l,int r,int idx)
{
    if(l==r)
    {
        tree[idx] = ;
        return;
    }
    int mid = (l+r)>>;
    build(l,mid,idx<<);
    build(mid+,r,idx<<|);
    pushup(idx);
}
void update(int pos,int v,int l,int r,int idx)
{
    if(l==r)
    {
        tree[idx] = max(tree[idx],v);
        return;
    }
    int mid = (l+r)>>;
    if(pos<=mid) update(pos,v,l,mid,idx<<);
    else update(pos,v,mid+,r,idx<<|);
    pushup(idx);
}
void query(int l,int r,int L,int R,int idx)
{
    if(l>=L&&R>=r)
    {
        MAX = max(MAX,tree[idx]);
        return;
    }
    int mid = (l+r)>>;
    if(mid>=L)  query(l,mid,L,R,idx<<);
    if(mid<R)  query(mid+,r,L,R,idx<<|);
}
 
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=; i<=n; i++)
        {
            scanf("%d",&a[i]);
            b[i] = a[i];
        }
        sort(b+,b++n);
        int cnt = unique(b+,b++n)-b;
        for(int i=; i<=n; i++) a[i] = lower_bound(b+,b+cnt,a[i]) - b;
        for(int i=; i<=n; i++)
        {
            dp[i][] = ;
            if (i >  && a[i]>a[i - ])
                dp[i][] = dp[i - ][] + ;
        }
        build(,n,);
        int ans = -;
        for(int i=; i<=n; i++)
        {
            dp[i][] = ;
            if(i>&&a[i]>)
            {
                if(a[i]>a[i-]) dp[i][] = dp[i-][]+;
                MAX = -;
                query(,n,,a[i]-,); /**找到最大的 dp[j][0] 满足 a[j]<a[i] && j<i,有必要解释一下这里
                    为什么是更新1~a[i]-1呢?因为我们找的是按照大小排名来的数,而不是，比如说 1 3 5 6 4
                    假设我找的是 a[5] ,所以我应该忽略中间的 5 6 ，直接找 1 3 .而我们的枚举顺序也保证了 j<i 这个条件.
                    个人觉得很巧妙.
                */
                dp[i][] = max(dp[i][],MAX+);
            }
            update(a[i],dp[i][],,n,);/**
                更新过程同样巧妙,也是更新的按照大小排名来的顺序,不要与下标弄混了
            */
            ans = max(ans,max(dp[i][],dp[i][]));
        }
        printf("%d\n",ans);
    }
    return ;
}