51Nod 1376 最长递增子序列的数量 —— LIS、线段树

题目链接：http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1376

 

1376 最长递增子序列的数量 

基准时间限制：1 秒 空间限制：131072 KB 分值: 160 难度：6级算法题

 

 收藏

 

 关注

 

数组A包含N个整数（可能包含相同的值）。设S为A的子序列且S中的元素是递增的，则S为A的递增子序列。如果S的长度是所有递增子序列中最长的，则称S为A的最长递增子序列（LIS）。A的LIS可能有很多个。例如A为：{1 3 2 0 4}，1 3 4，1 2 4均为A的LIS。给出数组A，求A的LIS有多少个。由于数量很大，输出Mod 1000000007的结果即可。相同的数字在不同的位置，算作不同的，例如 {1 1 2} 答案为2。

Input

第1行：1个数N，表示数组的长度。(1 <= N <= 50000)

第2 - N + 1行：每行1个数A[i]，表示数组的元素(0 <= A[i] <= 10^9)

Output

输出最长递增子序列的数量Mod 1000000007。

Input示例

5

1

3

2

0

4

Output示例

2

 

题解：

1.由于要统计个数，所以就不能用之前所谓的O(n^2)或O(nlogn)方法（这两种方法求的是LIS的长度，而不是个数）。

2.因此需要利用线段树进行统计：将输入的值进行离散化，然后在离散化后数组之上建立线段树（即以值建树而不是以下标建树）。线段树的每个结点需要记录两个信息： 该段的LIS的长度及个数。

 

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
using namespace std;
typedef long long LL;
const int INF = 2e9;
const LL LNF = 9e18;
const int MOD = 1e9+7;
const int MAXN = 5e4+10;

pair<int,int> getMax(pair<int,int> x, pair<int,int>y)
{
    if(x.first<y.first) x = y;
    else if(x.first==y.first) x.second = (x.second+y.second)%MOD;
    return x;
}

pair<int,int> len[MAXN*4];
void build(int u, int l, int r)
{
    if(l==r)
    {
        len[u].first = len[u].second = 0;
        return;
    }
    int mid = (l+r)>>1;
    build(u*2,l,mid);
    build(u*2+1,mid+1,r);
    len[u] = getMax(len[u*2],len[u*2+1]);
}

void add(int u, int l, int r, int pos, pair<int,int> val)
{
    if(l==r)
    {
        len[u] = getMax(len[u],val);
        return;
    }
    int mid = (l+r)>>1;
    if(pos<=mid) add(u*2,l,mid,pos,val);
    else add(u*2+1,mid+1,r,pos,val);
    len[u] = getMax(len[u*2],len[u*2+1]);
}

pair<int,int> query(int u, int l, int r, int x, int y)
{
    if(x<=l&&r<=y) return len[u];

    int mid = (l+r)>>1;
    pair<int,int> ret = make_pair(0,0);
    if(x<=mid) ret = getMax(ret,query(u*2,l,mid,x,y));
    if(y>=mid+1) ret = getMax(ret,query(u*2+1,mid+1,r,x,y));
    return ret;
}

int a[MAXN], M[MAXN], m;
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i = 1; i<=n; i++)
            scanf("%d",&a[i]);

        memcpy(M+1,a+1,n*sizeof(a[0]));
        M[n+1] = -INF;  //在最前面加个无穷小，防止区间溢出
        sort(M+1,M+1+n+1);         //离散化
        m = unique(M+1,M+1+n+1)-(M+1);

        build(1,1,m);
        for(int i = 1; i<=n; i++)
        {
            int pos = lower_bound(M+1,M+1+m,a[i])-(M+1);    //找到a[i]的上一个值的位置（这也是为什么要在离散化数组里加个无穷小）
            pair<int,int> t = query(1,1,m,1,pos);
            if(t.first==0) t.first = t.second = 1;  //如果在前面没人比它小，则自己作为第一个
            else t.first++;     //如果前面有人比它小，则长度+1（加上自己）
            add(1,1,m,pos+1,t);     //插入
        }
        printf("%d\n", query(1,1,m,1,m).second);
    }
}