hdu 3030 Increasing Speed Limits（树状数组求最长上升子序列）

在前边关于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的时候各不相同。希望哪位大神能详细的解释下。