hdu4638(离线算法+线段树)

Group

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 944    Accepted Submission(s): 510

Problem Description

There are n men ,every man has an ID(1..n).their ID is unique. Whose ID is i and i-1 are friends, Whose ID is i and i+1 are friends. These n men stand in line. Now we select an interval of men to make some group. K men in a group can create K*K value. The value of an interval is sum of these value of groups. The people of same group's id must be continuous. Now we chose an interval of men and want to know there should be how many groups so the value of interval is max.

 

Input

First line is T indicate the case number.
For each case first line is n, m(1<=n ,m<=100000) indicate there are n men and m query.
Then a line have n number indicate the ID of men from left to right.
Next m line each line has two number L,R(1<=L<=R<=n),mean we want to know the answer of [L,R].

 

Output

For every query output a number indicate there should be how many group so that the sum of value is max.

 

Sample Input

  
  

   
   1
5 2
3 1 2 5 4
1 5
2 4
  
  

 

Sample Output

  
  

   
   1
2
  
  

 

Source

2013 Multi-University Training Contest 4

 

Recommend

zhuyuanchen520

 

       本题要求给定区间内连续区间的个数。区间长度和查询次数之大，就说明要用线段树来优化，降低时间复杂度

        结合本题特点，可知常规的在线算法不可能体现线段树的优点。容易想到用离线算法，首先存储所有的查询，然后依据查询区间的右端点进行从小到大的排序。我们一次插入ID，线段树上从根节点到插入ID的叶节点都加1.然后判段该ID相邻的ID好是

否已插入，则左或右ID对应的位置减1，连续区间不能重复计数。若插入的ID的下标等于某一查询区间的右端点，则立即统计连续区间的个数。最后按照查询的先后顺序输出答案即可。

 

1.线段树做法：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;

const int MAXN=100000+100;
struct node1
{
	int left,right,index;
}Q[MAXN];
int postion[MAXN];
int ID[MAXN];
int ans[MAXN];
int da[MAXN];
struct node 
{
	int left,right,sum;//sum此处灵活处理
}tree[MAXN*4];

//1.建立以left,right为左右边界,将数组da中元素存储在首地址从1开始的线段树tree的叶节点上
void Build( int id,int left,int right)
{
    tree[id].left=left;
    tree[id].right=right;
	tree[id].sum=0;//此处灵活处理
    if(left==right)
    {
		//tree[id].sum=da[id];//此处可以直接初始化为对应da[id]
		return ;
    }
    else
    {
		int mid =(left+right)>>1;        
        Build(id<<1,left,mid);
        Build((id<<1)|1,mid+1,right);
		//tree[id].sum=tree[(id<<1)].sum+tree[(id<<1)|1].sum;
   }
}

//2.在线段树的叶节点pos处加val
void Updata(int id,int pos,int val)
{
    tree[id].sum+=val;
    if(tree[id].left==tree[id].right&&tree[id].left==pos)
    {
        return ;
    }
    int mid=(tree[id].left+tree[id].right)>>1;
    if(pos<=mid) 
        Updata(id<<1,pos,val);
    else 
        Updata((id<<1)|1,pos,val);
}

//3.查询区间[left,right]上的和
int Query(int id,int left,int right)
{
    if(tree[id].left==left&&tree[id].right==right)
    {
        return tree[id].sum;
    }
    int mid=(tree[id].left+tree[id].right)>>1;
    if(right<=mid)
        return Query(id<<1,left,right);
    if(left>=mid+1)
        return Query((id<<1)|1,left,right);
    return Query(id<<1,left,mid)+Query((id<<1)|1,mid+1,right);
}
//************************************************************

bool cmp(node1 a,node1 b)
{
	return a.right<b.right;
}

void init()
{
	memset(postion,0,sizeof(postion));
}
int main()
{
	int cas,n,q,i;
	cin>>cas;
	while(cas--)
	{
		scanf("%d%d",&n,&q);
		Build(1,1,n);
		for(i=1;i<=n;i++)
		{
			scanf("%d",&ID[i]);
			postion[ID[i]]=i;
		}
		for(i=1;i<=q;i++)
		{
			scanf("%d%d",&Q[i].left,&Q[i].right);
			Q[i].index=i;
		}
		sort(Q+1,Q+1+q,cmp);

		int id=1;
		for(i=1;i<=n;i++)
		{
			Updata(1,i,1);//在下表为i的位置添加1个元素
			if(ID[i]>1&&postion[ID[i]-1]<=i)//插入的元素有左临界且已在树状数组中
				Updata(1,postion[ID[i]-1],-1);//在下表为i的位置添加1个元素

			if(ID[i]<n&&postion[ID[i]+1]<=i)//插入的元素有右临界且已在树状数组中
				Updata(1,postion[ID[i]+1],-1);//在下表为i的位置添加1个元素

			while(Q[id].right==i)
			{
				ans[Q[id].index]=Query(1,Q[id].left,Q[id].right);
				id++;
			}
		}
		for(i=1;i<=q;i++)
			printf("%d\n",ans[i]);
	}
	return 0;
}

2.树状数组做法(此题只是求区间和，可以用树状数组来优化，二者实现的时间复杂度差不多，但树状数组编程简单、常数较小)

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;

const int MAXN=100000+100;
struct node
{
	int left,right,index;
}Q[MAXN];
int postion[MAXN];
int ID[MAXN];
int ans[MAXN];

int C[MAXN];
int Lowbit[MAXN];

//*****************************************************************
//C[i] = a[i-lowbit(i)+1] + …+ a[i],下表从1开始
//Lowbit[i]=i & ( i ^( i - 1));或Lowbit[i]=i &(-i); 
//1.查询
int QuerySum(int p)
//查询原数组中下标1-p的元素的和 
{ 
   int nSum = 0; 
   while( p>0 ) 
   {  
      nSum += C[p]; 
      p -= Lowbit[p]; 
   } 
    return nSum; 
} 
//2.修改+初始化
void Modify( int p,int val) 
//原数组中下表为p的元素+val，导致C[]数组中部分元素值的改变
{ 
    while( p <= MAXN) 
   { 
      C[p] += val; 
      p += Lowbit[p]; 
    } 
} 
//*****************************************************************

void init()
{
	memset(postion,0,sizeof(postion));
	memset(ans,0,sizeof(ans));
	memset(C,0,sizeof(C));
}

bool cmp(node a,node b)
{
	return a.right<b.right;
}


int main()
{
	int cas,n,q,i;
	cin>>cas;
	while(cas--)
	{
		scanf("%d%d",&n,&q);
		init();
		for(i=1;i<=n;i++)
		{
			scanf("%d",&ID[i]);
			postion[ID[i]]=i;
		}
		for(i=1;i<=q;i++)
		{
			scanf("%d%d",&Q[i].left,&Q[i].right);
			Q[i].index=i;
		}
		sort(Q+1,Q+1+q,cmp);

		int id=1;
		for(i=1;i<=n;i++)
		{
			Modify(i,1);//在下表为i的位置添加1个元素
			if(ID[i]>1&&postion[ID[i]-1]<=i)//插入的元素有左临界且已在树状数组中
				Modify(postion[ID[i]-1],-1);//在下表为i的位置添加1个元素

			if(ID[i]<n&&postion[ID[i]+1]<=i)//插入的元素有右临界且已在树状数组中
				Modify(postion[ID[i]+1],-1);//在下表为i的位置添加1个元素

			while(Q[id].right==i)
			{
				ans[Q[id].index]=QuerySum(Q[id].right)-QuerySum(Q[id].left-1);
				id++;
			}
		}
		for(i=1;i<=q;i++)
			printf("%d\n",ans[i]);
	}
	return 0;
}