在前边关于DP总结的文章中说了通过普通的DP法个二分查找法求最长上升子问题,最近在学习BIT,然后突然发现原来通过BIT也可以求最长上升子序列问题。本来想着可以通过类似的方法在O(nlogn)时间内求出,然而题目的意思是求出总和,这样的话二分法就不好使了,一开始也没有理解,不过通过单纯的求最长上升子序列,终于搞明白了。
先来看看求解普通的最长上升子序列问题:
题目中首先将重复的元素去掉,以为我们求的是严格意义上的上升序列,因此,相同的元素是没有任何意义的,所以先对所有元素排序,然后去除掉重复元素。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=110000;
int n,val[N],a[N];
int len,arr[N];
int lowbit(int x){
return x&(-x);
}
//原始的update
void update(int i,int x){
while(x<=len){
if(i>arr[x])
arr[x]=i;
x+=lowbit(x);
}
}
int query(int x){
int ans=0;
while(x){
if(arr[x]>ans)
ans=arr[x];
x-=lowbit(x);
}
return ans;
}
int main(){
while(~scanf("%d",&n)){
for(int i=0;i<n;i++){
scanf("%d",&val[i]);
a[i]=val[i];
}//排序去冲
sort(a,a+n);
len=unique(a,a+n)-a;
memset(arr,0,sizeof(arr));
int ans=1,tmp;
for(int i=0;i<n;i++){//这里val中保存的是可以插入元素的位置
val[i]=lower_bound(a,a+len,val[i])-a;
tmp=query(val[i])+1;//tmp保存的是当前位置左边比它小的数的个数,注意这里要加1,因为第i结束时需要给序列加1
if(tmp>ans)//取最大值,我们求得是最长上升的序列
ans=tmp;
update(tmp,val[i]+1);更新val[i]+1位置,注意tree中保存的是左边小的值,所以在真正求值时需要+1
}
printf("%d\n",ans);
}
return 0;
}
好了,搞明白了找个基本问题,杭电的这道题也就可以理解了:
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <map>
#include <algorithm>
#define MOD 1000000007
#define MAXN 500005
using namespace std;
int num[MAXN], A[MAXN], c[MAXN], seq[MAXN], cnt;
inline int lowbit(int x)
{
return x & -x;
}
//这里的update是正常的
inline void update(int pos, int val)
{
for (int i = pos; i <= cnt; i += lowbit(i))
{
c[i] += val;
if (c[i] >= MOD)
c[i] %= MOD;
}
}
inline int getsum(int pos)
{
int s = 0;
for (int i = pos; i > 0; i -= lowbit(i))
{
s += c[i];
if (s >= MOD)
s %= MOD;
}
return s;
}
int main()
{
int T, n, m;
long long X, Y, Z, res;
scanf("%d", &T);
for (int ca = 1; ca <= T; ++ca)
{
res = 0;
map<int,int>mp;
scanf("%d %d %I64d %I64d %I64d", &n, &m, &X, &Y, &Z);
memset(c, 0, sizeof (c));
for (int i = 0; i < m; ++i)
{
scanf("%d", &A[i]);
}
for (int i = 0; i < n; ++i)
{
num[i+1] = A[i%m];
seq[i] = num[i+1];
A[i%m] = (X*A[i%m]+Y*(i+1))%Z;
}
//其中num和seq保存的值是一模一样的
sort(num+1, num+1+n);
//去除临近元素,cnt表示的是一共有多少个不同的元素
//这里进行的是离散化的操作,对于最长上升子序列来说,相同元素是毫无意义的
cnt = unique(num+1, num+1+n) - (num+1);
for (int i = 1; i <= cnt; ++i)
{//上边是通过二分找位置,这里使用的map来记录位置
mp[num[i]] = i;
}
update(1, 1);
for (int i = 0; i < n; ++i)
{ //注意这里是累加,而上边的代码中是取最大值
long long x = getsum(mp[seq[i]]);
res += x;
if (res > MOD)
res %= MOD;
//给下一个位置上update时的值是x
update(mp[seq[i]]+1, x);
}
printf("Case #%d: %I64d\n", ca, res);
}
return 0;
}
这样居然跑了9000MS,险过。这个是别人的代码,拿来学习下,然后想想为什么不用二分呢?根据位置来确定岂不是更快,少了map内存也应该更少才对,修改代码如下:
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <map>
#include <algorithm>
#define MOD 1000000007
#define MAXN 500005
using namespace std;
int num[MAXN], A[MAXN], c[MAXN], seq[MAXN], cnt;
inline int lowbit(int x)
{
return x & -x;
}
//这里的update是正常的
inline void update(int pos, int val)
{
for (int i = pos; i <= cnt; i += lowbit(i))
{
c[i] += val;
if (c[i] >= MOD)
c[i] %= MOD;
}
}
inline int getsum(int pos)
{
int s = 0;
for (int i = pos; i > 0; i -= lowbit(i))
{
s += c[i];
if (s >= MOD)
s %= MOD;
}
return s;
}
int main()
{
int T, n, m;
long long X, Y, Z, res;
scanf("%d", &T);
for (int ca = 1; ca <= T; ++ca)
{
res = 0;
map<int,int>mp;
scanf("%d %d %I64d %I64d %I64d", &n, &m, &X, &Y, &Z);
memset(c, 0, sizeof (c));
for (int i = 0; i < m; ++i)
{
scanf("%d", &A[i]);
}
for (int i = 0; i < n; ++i)
{
num[i+1] = A[i%m];
seq[i] = num[i+1];
A[i%m] = (X*A[i%m]+Y*(i+1))%Z;
}
//其中num和seq保存的值是一模一样的
sort(num+1, num+1+n);
//去除临近元素,cnt表示的是一共有多少个不同的元素
//这里进行的是离散化的操作,对于最长上升子序列来说,相同元素是毫无意义的
cnt = unique(num+1, num+1+n) - (num+1);
for (int i = 0; i < n; ++i)
{ //注意这里是累加,而上边的代码中是取最大值
A[i]=lower_bound(num+1,num+cnt+1,seq[i])-num-1;
long long x = getsum(A[i])+1;
res += x;
if (res > MOD)
res %= MOD;
//给下一个位置上update时的值是x
update(A[i]+1, x);
}
printf("Case #%d: %I64d\n", ca, res);
}
return 0;
}
这样的话仅仅需要2703MS,但是内存只减少了80B,额,看来stl中的map做得好牛逼。。。
还得注意下,求最长上升子序列和求子序列个数的时候,BIT中的update和getsum各不相同,要说起解释来呢,也不知该怎么解释,可能对BIT的理解还不够深刻,一个是求最大值,一个是求和,所以update和getsum的时候各不相同。希望哪位大神能详细的解释下。