链接：
Find the nondecreasing subsequences
Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 1182 Accepted Submission(s): 408
Problem 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
Author
8600
Recommend
lcy
题意：
给你一个有序序列, 求有多少个不下降子序列
结果对 10^9+7 取模
注意：不下降【相等也可以】
每个元素本身也算一个
算法：离散化+树桩数组+简单dp 思想
思路：
这道题目的数据比较大 1 <= n <= 100000 0 <= si <= 2^31 如果数据比较小直接 DP就可以解决了。当然这些比赛的时候都没有想到, 找题解的时候突然看到了奋斗青春 的 DP 思想，然后去神牛 Maxtri67 那儿学了下什么是离散化 , 后来kuangbin 大神又给我说了另外一种离散化的思想的两种实现方法。
我们先分析一下假设数据比较小的情况：
dp[a[j]]=sum( dp[a[i]] )+1; (i>=1 && i<j && a[j]>=a[i]) //单独的a[j]也算一个
//a[] 存序列中的元素值, dp[i] 表示值为 i 结尾形成的子序列的个数
memset(dp,0,sizeof(dp));
for(int i = 1; i <= n; i++)
{
for(int j = 1; j < i; j++) //如果 a[i] 出现在 a[j] 后面而又不比 a[j] 小, 那么可以直接加在 a[j] 后面,形成新的子序列
{
if(a[i] >= a[j])
dp[a[i]] += dp[a[j]];
}
dp[a[i]]++; //自己单独也是一个, 由于是直接加的, 所以覆盖掉了前面的 dp[a[i]], 不能直接 ans += dp[a[i]]; 而是计算完后再遍历一次
}
int ans = 0; // 暂且不考虑对 10^9+7 取模的情况
for(int i = 1; i < maxn; i++)
ans += dp[i];
printf("%d\n", ans);
但是 a[i] 的值最大到了 2^31 , 明显不可能开一个这么大的数组
如是需要离散化一下, 把结果映射到 1-n 这个区间,等下我会详细的解释下我对这题的离散化的理解, 第一个离散化题目Orz
说的这么高深, 其实一般的离散化简单排序下再做些小处理就可以了。
现在我们先抛下离散化, 看下这个 DP 的结构, 就是对前面满足条件的求和有木有, 考虑到 n 比较大, 更新的次数比较多, 那么我们是否可以想到一个快速求和的方法, 树状数组正好能快速求一段序列的和的, 那么我们是否可以把这道题目往树桩数组上想。
至于关于树状数组的理解, 我是看的 lrj 《训练指南》P194-P196 上的介绍了,网上也有很多资料,自认为还没有办法说的特别清楚,这里不再仔细介绍, 你只需要记住树桩数组能够快速的求一段序列的和,并且能够快速更新每一个点的值那么就可以往下看了。
如果实在不了解的：先记住下面这句话, 然后再继续往下看。看过树状数组的可以直接忽略。。。
树桩数组的下标从 1 开始到 N , 数组 a[] 记录序列的值 c[i] 记录以 a[i] 结束的某段 a[j]到 a[i] 的连续和
ＰＳ：具体是那一段，这里我一句两句也说不清楚，先记住好了，对下面的思想的分析没有太大的影响
有两个函数： add(int i , int val) // 把a[i] 更新加上 val ,同时更新相应的一段 c[]
sum(int i) // 求 a[1] +a[2] +...+ a[i] 的连续和
如何转换成树桩数组求解？
这题求的是不下降子序列的个数。
也就是说符合要求的序列元素的后面的一个的值总是大于或等于前一个元素的【废话一句可以忽略Orz】
那么我们可以先对输入的元素 a[i] 按照从小到大做一个排序处理。
这样排序后前面的数字肯定小于等于后面的数字是不是。那么依次遍历的时候,直接把当前的数字插入到前面已经处理过的数字所形成所
有子序列后面那么就可以形成新的子序列了。那么排序后,我们只要弄个数组把每一个以 a[i] 结尾的对应的序列个
数
记
录
下来就可以了, 【顺序打乱了,后面会说怎么处理,这里先不管】假设记录个数的数组是 num[] 那么最后就把每一个 num[] 相加是不是就是最后
的结果了。中间注意下取模。
好像有点树状数组的感觉了，不过还是没什么用的样子，继续往下看。。。
但是这样嵌入了离散化的思想：把原来的应该开到 2^31 的数组 dp [] 优化到了长度为 100000 num[] 直接映射到 1 到 N 求解
又装逼了, 不就是个排序处理还说的这么高深。
下面以类似于样例中的已经排序好了的解释下上一段关于离散化的思想：
3
100 200 300
对于第一个数 100 ：以 1 结尾形成一个不下降子序列就是他自己 num[1] = 1
对于第二个数 200 ：以 2 结尾形成的不下降子序列： (1) 加到 1 后面 num[2] += num[1] = 1
(2) 自己单独成一个子序列 num[2]++ = 2
对于第三个数 300： 以 3 结尾形成的不下降子序列： (1) 加到前面形成的子序列的后面 num[3] = num[1] + num[2] = 3
(2) 自己单独成一个 num[3]++ = 4
那么最后的结果就是 7
是否体会到原来要开到的数组 dp[300]， 现在 num[3] 就解决了, 这就是传说中的离散化。。。
PS :其实这个思路并不严谨,稍微改下数据就会有很多错误的地方，只是为了清楚离散化就先用了。。。严谨看后面。
因为我排序后,忽略了每一个元素在原来的序列中出现的位置就直接把大的插入到了小的后面。
这样就会陷入这样一个误区：变成了子序列的个数 = 元素个数的非空子集个数，照成最后的结果变成 pow(2, n) - 1而这样是错的。
解决这样的先后处理问题就必须用到树状数组的思想，先不管这个问题，直接考虑对于这题如何离散化。
对于这题如何离散：
离散化就是排序下，再随便处理下就 O 了。
思路一：
定义一个结构体, 记录每一个元素的初始下标 index 和元素的值 value
等我先写完思路了再具体介绍为何还要定义下标【这里先提一下, 方便后面嵌入树状数组】
对元素的值 value 从小到大排序【前面已经分析过】
对于 value 一样的按照 index由小到大排序 【这一点下面会解释】
还是以上面的 num[] 数组记录的思想来解释：
3
1 3 3
如果只对 value 排序
那么排序后原来的元素的下标的排列可能会出现两种情况：
情况一： 1 2 3 【这样是正确的】
num[1] = 1
num[2] = num[1]+1 = 1 + 1 = 2
num[3] = num[1] + num[2] + 1 = 1+2 +1 = 4
最后的结果为 1 + 2 + 4 = 7
情况二： 1 3 2 【错误】
num[1] = 1
num[2] = num[1] + 1 = 1 + 1 = 2
num[3] = num[1] + 1 = 2
最后的结果为 1 + 2 + 2 = 5 WA
为什么对于情况一的 num[3] 要加上 num[2] 但是情况二的 num[3] 却没有 ？
这里就要说下为何用树桩数组? 如何用树桩数组了?,而不是直接的简单相加就好了.
再次强调一下树桩数组的作用:快速更新每一个元素的值, 快速求出任意一段连续子序列的和。
为了应用于树桩数组：每次求 num[i] 应该转换成 num[i] = num[1] + ... +num[i-1] +1
从而借用树状数组快速求前缀和的思想求出 num[i] ,
但是如果仅仅是这样，好像无法体现到树桩数组的优越性而且也陷入了上面解释离散化的映射时出现的误区
不要忘了，树桩数组还有一个优越性：快速更新每个元素的值。
如果排序后,我们遍历到第 i 个元素时求的不是 num[i] 而是 a[i] 原来对应的编号 index 的 num[index] 来记
录
以 a[i] 结尾的不下降子序列的个数
是不是就解决了前
面的误区问题。
直接对元素的 a[i] 原来未排序时的编号做 num 处理。
3
1 7 5
排序后： 1 5 7
对应原来的编号：1 3 2
依次遍历排序后的元素： 对于元素 1 ：num[1] = 1;
对于元素 5 ：num[3] = num[1]+num[2] + 1 = 1+0 + 1 = 2
对于元素 2 ：num[2] = num[1] + 1 = 1 + 1 = 2
ans = num[1]+num[2]+num[3] = 5
这样就解决了元素出现的先后问题,而且也是离散化后把要处理的问题映射到了 1 到 N 这个区间,
但是还是
没有说明元素的值一样却要对出现的顺序也排序。
其实到了这里，自己也应该想明白了，我还是再写下好了。
注意到：处理的过程不断的更新相应的 num[] 对应于树桩数组中快速更新元素值的思想。
num[index] = num[1]+...+num[index-1] + 1对应于树状数组快速求前缀和的思想。
对于情况一: 排序前后并未影响原来的顺序,所以可以直接把大的元素插在前面所有出现过的元素后面形成新的不下降子序列.
对于情况二: 加入了树状数组的思想其实是这样算的
num[1] = 1;
num[3] = num[1]+num[2] + 1 = 1+0+1 = 2;
num[2] = num[1] + 1 = 2 ;
ans = 1+2+2 = 5
所以：对于一样的元素, 先出现的一定要先处理
思路二：
不用定义结构体, 按照元素的值从小到大排序 ,然后对于重复元素的下标定义成一样的就可以了
比如说样例：
3
1 3 3
排序后的下标是： 1 2 2
而不是原来的：1 2 3 那么就不用纠结什么元素一样的时候,是先排前面的还是后面的问题了。
这样有两种方法处理, 但是效率没有思路一的高。具体看程序实现。
code：
code1: 离散化思路一的代码：
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn = 100000+10;
const int mod = 1000000007;
int c[maxn];
int n;
struct Node{
int value; //对应元素的值
int index; //元素初始编号
}node[maxn];
bool cmp(Node a, Node b) //先按元素值从小到大排序,元素值一样，再按照 编号从小到大排序
{
if(a.value == b.value) return a.index < b.index;
else return a.value < b.value;
}
int lowbit(int x)
{
return x&(-x);
}
void add(int index, int value) //快速更新 ：节点 index 增加 value
{
while(index <= n)
{
c[index] = (c[index]+value) % mod;
index += lowbit(index);
}
}
int sum(int index) //快速求前缀和
{
int ret = 0;
while(index > 0)
{
ret = (ret+c[index])%mod;
index -= lowbit(index);
}
return ret; //勿忘
}
int main()
{
while(scanf("%d", &n) != EOF)
{
memset(node, 0, sizeof(node));
memset(c, 0, sizeof(c));
for(int i = 1; i <= n; i++)
{
scanf("%d", &node[i].value);
node[i].index = i;
}
sort(node+1, node+n+1, cmp); //排序
int tmp = 0;
for(int i = 1; i <= n; i++)
{
tmp = sum(node[i].index)+1; //求处理过后的前缀和相当于思路中的 num[index]
tmp %= mod;
add(node[i].index, tmp); // 相当于思路中给 num[index]增加 tmp
}
printf("%d\n", sum(n));
}
return 0;
}
code2:
离散化思路二, 实现方法一：
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<map>
using namespace std;
const int MAXN = 100010;
const int MOD = 1e9+7;
int c[MAXN];
int n;
int a[MAXN];
int b[MAXN];
int lowbit(int x)
{
return x&(-x);
}
void add(int i,int val)
{
while(i <= n)
{
c[i] += val;
c[i] %= MOD;
i += lowbit(i);
}
}
int sum(int i)
{
int s = 0;
while(i > 0)
{
s+=c[i];
s%=MOD;
i-=lowbit(i);
}
return s;
}
int main()
{
while(scanf("%d",&n) == 1)
{
for(int i = 1;i <= n;i++)
{
scanf("%d",&a[i]);
b[i] = a[i]; //存 a[i],
}
sort(b+1,b+n+1);
map<int,int>mp;
mp.clear();
int index = 1;
for(int i = 1;i <= n;i++)
{
if(mp[b[i]]==0) mp[b[i]] = index++; //相同的元素下标不变, 元素不同下标+1
}
for(int i = 1;i <= n;i++)
{
a[i] = mp[a[i]]; //存 a[i] 原来对应的值,离散化后对应的下标
}
memset(c,0,sizeof(c));
int ans = 0;
for(int i = 1;i <= n; i++)
{
int cc = sum(a[i]);
add(a[i],cc+1);
}
printf("%d\n",sum(n));
}
return 0;
}
code3:
离散化思路二, 实现方法二：
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<map>
using namespace std;
const int MAXN = 100010;
const int MOD = 1e9+7;
int c[MAXN];
int n;
int a[MAXN];
int b[MAXN];
int lowbit(int x)
{
return x&(-x);
}
void add(int i,int val)
{
while(i <= n)
{
c[i] += val;
c[i] %= MOD;
i += lowbit(i);
}
}
int sum(int i)
{
int s = 0;
while(i > 0)
{
s+=c[i];
s%=MOD;
i-=lowbit(i);
}
return s;
}
int main()
{
while(scanf("%d",&n) == 1)
{
for(int i = 1;i <= n;i++)
{
scanf("%d",&a[i]);
b[i] = a[i]; //b[] 存 a[]
}
sort(b+1,b+n+1);
int t = unique(b+1,b+n+1) - b; //消除重复的元素, 把不同元素排到前面【其实是换了一下顺序重复的放后面了】
//printf("test: t = %d\n", t);
map<int,int> mp;
for(int i = 1; i < t; i++) // 前面的 t 返回的是 b 中有序元素的长度的下一个位置
mp[b[i]] = i;
for(int i = 1;i <= n;i++) //后面都和前一个代码一样了
{
a[i] = mp[a[i]];
}
memset(c,0,sizeof(c));
for(int i = 1;i <= n;i++)
{
int cc = sum(a[i]);
add(a[i],cc+1);
}
printf("%d\n",sum(n));
}
return 0;
}
524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
