BZOJ4241 历史研究

别问我怎么发文章

我想下载ZJOI2014的数据

Mo’s Algorithm with Roll-Back

回滚莫队算法

对于删除操作难维护答案但添加易维护的或者 添加难维护但是删除易维护的莫队题，可以使用回滚莫队算法。

历史研究是第一种

对于这种，我们选择

1.对于在同一个块内的询问，$O(n \sqrt{n})$暴力计算

2.对于不在同一块的询问，莫队排序后，形成了左端点在同一个块内的若干询问，

对于这些询问，我们只维护这个同块的下一个块的起点到这些询问的右端点的答案情况，因为右端点递增，左面固定在一处，所以只有添加。

然后回答每一个询问的时候暴力统计左端点到下一个块左端对答案的影响，统计完再改回去，

还有一个问题就是如果这个询问的左端点和上个的不在一个块，那直接重置答案统计变量和答案统计数组，暴力重新统计。

这样把复杂度压回了$O(n \sqrt{n})$O\left( n\sqrt{n} \right)的级别

·

下一点是添加难维护但是删除易维护的莫队题

对于这类我们采取和上面相同的思想，但是我没见过任何这样的题，属于有解法无题的东西。

对于同块询问当然还是暴力

非同块询问你需要这么做，莫队思想排序完后倒序处理。

对于左端点同块的若干询问，维护这个同块的起点到目前询问右端点的答案情况。倒序处理只有删除操作。

每次回答时暴力删除到询问的左端点，然后改回去。

对于目前询问和上一个询问左端点不同块的情况，做法和第一类问题一样。

·

最后是这个题的代码,全开longlong结果跑了大概20s……大概是ll太慢了。你可以少开几个ll

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<string>
#include<algorithm>
#include<iterator>
#include<queue>
#include<vector>
using namespace std;

struct asksx
{
	long long ans,l,r,codex;
}ask[100010]={0};

long long blksz,n,seq[100010]={0},q,nowans,belong[100010]={0};
long long setx[100010]={0},sta[100010]={0},sta2[100010]={0};

inline void readx(long long& x)
{
	x=0; long long k=1; register char ch=0;
	while (ch<'0' || ch>'9') { ch=getchar(); if (ch=='-') k=-1; }
	while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); }
	x*=k;
}

inline bool cmp1(asksx a,asksx b)
{
	if (belong[a.l]==belong[b.l]) return a.r<b.r;
	else return a.l<b.l;
}
inline bool cmp2(asksx a,asksx b) { return a.codex<b.codex; }

inline void process1()
{
	int ent=n; blksz=sqrt(n);
	memcpy(setx,seq,sizeof(seq));
	sort(setx+1,setx+n+1);
	for (int i=1;i<n;i++) if (setx[i]==setx[i+1]) { setx[i]=2*1e9; ent--; }
	sort(setx+1,setx+n+1);
	
	for (int i=1;i<=n;i++)
	{
		int lx=1,rx=ent,mid;
		while (lx<=rx)
		{
			mid=(lx+rx)>>1;
			if (setx[mid]==seq[i]) { seq[i]=mid; break; }
			else if (setx[mid]>seq[i]) rx=mid-1;
			else lx=mid+1;
		}
	}
	
	for (int i=1;i<=n;i++) belong[i]=(i-1)/blksz+1;
	sort(ask+1,ask+q+1,cmp1);
}

int main()
{
	readx(n); readx(q);
	for (int i=1;i<=n;i++) readx(seq[i]);
	for (int i=1;i<=q;i++)
	{
		readx(ask[i].l); readx(ask[i].r);
		ask[i].codex=i;
	}
	
	process1();
	
	long long lpos=1,rpos=0,qll=0,rawans;
	for (int i=1;i<=q;i++)
	{
		if (belong[ask[i].l]!=belong[ask[i-1].l])
		{
			memset(sta,0,sizeof(sta));
			nowans=0; lpos=qll=belong[ask[i].l]*blksz+1; rpos=lpos-1;
		}
		if (belong[ask[i].l]==belong[ask[i].r])
		{
			long long cans=0;
			for (int j=ask[i].l;j<=ask[i].r;j++)
			{
				sta2[seq[j]]++; cans=max(cans,sta2[seq[j]]*setx[seq[j]]);
			}
			for (int j=ask[i].l;j<=ask[i].r;j++) sta2[seq[j]]=0;
			ask[i].ans=cans;
		}
		else
		{
			while (rpos<ask[i].r)
			{
				rpos++; sta[seq[rpos]]++;
				nowans=max(nowans,sta[seq[rpos]]*setx[seq[rpos]]);
			}
			rawans=nowans;
			while (lpos>ask[i].l)
			{
				lpos--; sta[seq[lpos]]++;
				rawans=max(rawans,sta[seq[lpos]]*setx[seq[lpos]]);
			}
			ask[i].ans=rawans;
			//roll_back
			while (lpos<qll) { sta[seq[lpos]]--; lpos++; }
		}
	}
	
	sort(ask+1,ask+q+1,cmp2);
	for (int i=1;i<=q;i++) printf("%lld\n",ask[i].ans);
	return 0;
}