ACM学习历程——HDU2227 Find the nondecreasing subsequences（线段树 && dp）

Description

How many nondecreasing subsequences can you find in the sequence S = {s1, s2, s3, ...., sn} ? For example, we assume that S = {1, 2, 3}, and you can find seven nondecreasing subsequences, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}.

 

Input

The input consists of multiple test cases. Each case begins with a line containing a positive integer n that is the length of the sequence S, the next line contains n integers {s1, s2, s3, ...., sn}, 1 <= n <= 100000, 0 <= si <= 2^31.

 

Output

For each test case, output one line containing the number of nondecreasing subsequences you can find from the sequence S, the answer should % 1000000007.

 

Sample Input

3

1 2 3

 

Sample Output

7

这个题目要求的是上升子序列的个数。

若设sum[i]表示以i为最后一个数的上升子序列的个数。

首先可以得到的是sum[i] = 1 + ∑(sum[j]) (a[j] <= a[i])。（ps：加1是因为子序列可以只包含一个数）

但是遍历sum[j]这个操作的时间需要O(n)，所以要对这个操作进行优化。

很容易想到的是区间和，但是这个操作只需要求在i之前比a[i]小的那些点的和。

于是可以先把所有点的值初始化为0，然后从值最小的那个数开始求解，这样在求小的数的时候，大的数对应的值是0，这样的话大的数的贡献就是0，相当于没有加入计算。

举例说明：

对于序列5 1 3 2 4

先求1这个数，那么sum[1]就是[1, 2]区间内val[i]的和加1，即0+1。此时val[1]更新为1，sum[1]为1。

再求2这个数，那么sum[2]就是[1, 4]区间内val[i]的和加1，即1+1。此时val[2]更新为2，sum[2]为2。

再求3这个数，那么sum[3]就是[1, 3]区间内val[i]的和加1，即1+1。此时val[3]更新为2，sum[3]为2。

再求4这个数，那么sum[4]就是[1, 5]区间内val[i]的和加1，即1+2+2+1。此时val[4]更新为5，sum[4]为6。

最后求5这个数，那么sum[5]就是[1, 1]区间内val[i]的和加1，即0+1。此时val[5]更新为1，sum[5]为1。

所以答案就是sum[i]的和，就是12。

由于可以边求边加，所以sum数组可以省去。

 

代码：

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <algorithm>

#define LL long long

#define N 1000000007



using namespace std;



//线段树

//区间每点增值，求区间和

const int maxn = 100005;

struct node

{

    int lt, rt;

    int val;

}tree[4*maxn];



//向上更新

void PushUp(int id)

{

    tree[id].val = (tree[id<<1].val + tree[id<<1|1].val)%N;

}



//建立线段树

void Build(int lt, int rt, int id)

{

    tree[id].lt = lt;

    tree[id].rt = rt;

    tree[id].val = 0;//每段的初值，根据题目要求

    if (lt == rt)

    {

        //tree[id].val = 1;

        return;

    }

    int mid = (lt + rt) >> 1;

    Build(lt, mid, id<<1);

    Build(mid+1, rt, id<<1|1);

    //PushUp(id);

}



//增加区间内每个点固定的值

void Add(int lt, int rt, int id, int pls)

{

    if (lt <= tree[id].lt && rt >= tree[id].rt)

    {

        tree[id].val += pls * (tree[id].rt-tree[id].lt+1);

        tree[id].val %= N;

        return;

    }

    int mid = (tree[id].lt + tree[id].rt) >> 1;

    if (lt <= mid)

        Add(lt, rt, id<<1, pls);

    if (rt > mid)

        Add(lt, rt, id<<1|1, pls);

    PushUp(id);

}



//查询某段区间内的he

LL Query(int lt, int rt, int id)

{

    if (lt <= tree[id].lt && rt >= tree[id].rt)

        return tree[id].val;

    int mid = (tree[id].lt + tree[id].rt) >> 1;

    LL ans = 0;

    if (lt <= mid)

        ans += Query(lt, rt, id<<1);

    if (rt > mid)

        ans += Query(lt, rt, id<<1|1);

    return ans%N;

}



struct node1

{

    LL val;

    int id;

}p[100005];



bool cmp(node1 a, node1 b)

{

    if (a.val != b.val)

        return a.val < b.val;

    else

        return a.id < b.id;

}



int n, len;

int sum;

LL ans;



int main()

{

    //freopen("test.in", "r", stdin);

    while (scanf("%d", &n) != EOF)

    {

        for (int i = 0; i < n; ++i)

        {

            p[i].id = i+1;

            scanf("%I64d", &p[i].val);

        }

        sort(p, p+n, cmp);

        ans = 0;

        Build(1, n, 1);

        for (int i = 0; i < n; ++i)

        {

            sum = Query(1, p[i].id, 1)+1;

            Add(p[i].id, p[i].id, 1, sum);

            ans += sum;

            ans %= N;

        }

        printf("%I64d\n", ans);

    }

    return 0;

}