hdu 1806 ， pku3368 Frequent values

题意： 

   给n个数，已经按从大到小顺序排列好，一共有q个询问，每次询问一个区间，问这个区间中出现次数最多的数是什么。

   题目数据范围：

   数的个数，1 <= n <= 100000

   询问次数，1 <= q <= 100000

   每个数的大小，-100000 <= ai <= 100000

    

   很容易想到建立线段树，并在线段树的每个节点中保存区间中出现次数最多的数

   需要解决的问题，两个子结点的信息如何合并到父节点。

   很显然，子结点中出现次数最多的数不一定就是父节点中出现次数最多的数，

   有可能一个数在两个子结点中的出现次数都不是最多，但是子结点合并成父节点后，这个数的出现次数就最多了

   考虑到题目中的重要条件，数组中的数是有序的！

   当左子节点区间最右的数与右子区间最左的数相等时，这个相等的数的出现次数可能最多

   需要记录节点区间最左和最右的数的信息

 

  我的想法就是定义一个结构体：

struct node{

int l,r;

int count,num;

int lcount,lnum;

int rcount,rnum;

};

l,r存该节点的边界。 count存该节点中出现最多的数字的个数，num存该节点中出现最多的数字。

lcount 存该节点左端连续出现的数字的个数， lnum存该节点左端连续出现的数字。

rcount 存该节点右端连续出现的数字的个数， rnum存该节点右端连续出现的数字。

建树的时候初始化的时候比较麻烦一点， 每次询问的时候不是很麻烦。。

代码：

# include<stdio.h>

# include<string.h>

# define N 100005

struct node{

	int r,l;

	int num,count;

	int rnum,rcount;

	int lnum,lcount;

}tree[4*N];

int a[N],MAX;

void bulid(int l,int r,int t)//建树

{

	int mid,ans;

	tree[t].l=l;

	tree[t].r=r;

	if(l==r) 

	{

		tree[t].count=tree[t].lcount=tree[t].rcount=1;

		tree[t].num=tree[t].lnum=tree[t].rnum=a[l];

		return;

	}

	mid=(l+r)/2;

	bulid(l,mid,2*t);

	bulid(mid+1,r,2*t+1);



	if(tree[2*t].count>=tree[2*t+1].count) 

	{

		tree[t].num=tree[2*t].num;

		tree[t].count=tree[2*t].count;

	}

	else 

	{

		tree[t].num=tree[2*t+1].num;

		tree[t].count=tree[2*t+1].count;

	}

	tree[t].lnum=tree[2*t].lnum;

	tree[t].lcount=tree[2*t].lcount;

	tree[t].rnum=tree[2*t+1].rnum;

	tree[t].rcount=tree[2*t+1].rcount;

	if(tree[2*t].rnum==tree[2*t+1].lnum)

	{

		ans=tree[2*t].rcount+tree[2*t+1].lcount;

		if(ans>tree[t].count) 

		{

			tree[t].count=ans;

			tree[t].num=tree[2*t].rnum;

		}

		if(tree[2*t+1].lnum==tree[2*t].lnum) tree[t].lcount+=tree[2*t+1].lcount;

		if(tree[2*t].rnum==tree[2*t+1].rnum) tree[t].rcount+=tree[2*t].rcount;

	}

}

void updata(int l,int r,int t)

{

	int mid,ans1,ans2;

	if(tree[t].l==l && tree[t].r==r) 

	{

		if(tree[t].count>MAX) MAX=tree[t].count;

		return;

	}

	if(r<=tree[2*t].r) updata(l,r,2*t);

	else if(l>=tree[2*t+1].l) updata(l,r,2*t+1);

	else

	{

		mid=tree[2*t].r;

		updata(l,mid,2*t);

		updata(mid+1,r,2*t+1);

		if(tree[2*t].rnum == tree[2*t+1].lnum) 

		{

			if(a[l]!=tree[2*t].rnum) ans1=tree[2*t].rcount;

			else ans1=mid-l+1;

			if(a[r]!=tree[2*t+1].lnum) ans2=tree[2*t+1].lcount;

			else ans2=r-mid;

			if(ans1+ans2 > MAX) MAX=ans1+ans2;

		}

	}

}

int main()

{

	int i,Q,start,end,n;

	while(scanf("%d",&n)!=EOF && n)

	{

		scanf("%d",&Q);

		for(i=1;i<=n;i++)

			scanf("%d",&a[i]);

		bulid(1,n,1);

		while(Q--)

		{

			scanf("%d%d",&start,&end);

			if(start==end) {printf("1\n");continue;}

			MAX=0;

			updata(start,end,1);

			printf("%d\n",MAX);

		}

	}

	return 0;

}