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

在前边关于DP总结的文章中说了通过普通的DP法个二分查找法求最长上升子问题,最近在学习BIT,然后突然发现原来通过BIT也可以求最长上升子序列问题。本来想着可以通过类似的方法在O(nlogn)时间内求出,然而题目的意思是求出总和,这样的话二分法就不好使了,一开始也没有理解,不过通过单纯的求最长上升子序列,终于搞明白了。

先来看看求解普通的最长上升子序列问题:

题目中首先将重复的元素去掉,以为我们求的是严格意义上的上升序列,因此,相同的元素是没有任何意义的,所以先对所有元素排序,然后去除掉重复元素。

#include
#include
#include
#include

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;ians)//取最大值,我们求得是最长上升的序列
                ans=tmp;
            update(tmp,val[i]+1);更新val[i]+1位置,注意tree中保存的是左边小的值,所以在真正求值时需要+1
        }
        printf("%d\n",ans);
    }
    return 0;
}

好了,搞明白了找个基本问题,杭电的这道题也就可以理解了:


#include 
#include 
#include 
#include 
#include 
#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;
		mapmp;
		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 
#include 
#include 
#include 
#include 
#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;
		mapmp;
		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的时候各不相同。希望哪位大神能详细的解释下。

你可能感兴趣的:(树状数组/线段树)