LOJ6285 数列分块入门9（分块毒瘤）

最新推荐文章于 2021-09-22 23:09:42 发布

邵光亮

最新推荐文章于 2021-09-22 23:09:42 发布

阅读量10w+

点赞数 1

分类专栏：数据结构——线段树

本文链接：https://blog.csdn.net/qq_43627087/article/details/105145644

版权

数据结构——线段树专栏收录该内容

20 篇文章 0 订阅

订阅专栏

题目描述：

给出一个长为的数列，以及个操作，操作涉及询问区间的最小众数。

输入格式

第一行输入一个数字。

第二行输入个数字，第个数字为，以空格隔开。

接下来输入行询问，每行输入两个数字、，以空格隔开。

表示查询位于的数字的众数。

输出格式

对于每次询问，输出一行一个数字表示答案。

样例

样例输入

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

样例输出

1
2
2
2

题意：

给出区间内的最小众数

分块，离散化每个数，开 $v e c t o r$ 记录每个数 $p$ 出现的位置，这样就能二分出 $L ， R$ 以内 $p$ 的个数了。先预处理出任意两块的众数 $f [i] [j]$ ，这样众数就是 $f [i] [j]$ 和旁边两块数中的其中一个了，直接遍历这些数即可。但是这道题不像普通的分块开 $\sqrt{n}$ 就行，这个得把块再缩小，把时间复杂度优化。

AC代码：

const int N = 1e5 + 10;
struct Block
{
	int l, r;
} b[N];
int a[N], belong[N];
int f[10000][10000];
int num[N];
int n, block;
vector<int> vv;
vector<int> pos[N];
void init()
{
	rep(i, 1, belong[n])
	{
		rep(j, 0, vv.size())
			num[j] = 0;
		int mode = INF, NUM = 0;
		rep(j, b[i].l, n)
		{
			num[a[j]]++;
			if (num[a[j]] > NUM || (num[a[j]] == NUM && a[j] < mode))
			{
				mode = a[j];
				NUM = num[a[j]];
			}
			f[i][belong[j]] = mode;
		}
	}
}
int getNum(int l, int r, int v)
{
	int t = upper_bound(pos[v].begin(), pos[v].end(), r) - lower_bound(pos[v].begin(), pos[v].end(), l);
	return t;
}
int query(int l, int r)
{
	int bl = belong[l], br = belong[r];
	int ans = INF, NUM = 0;
	if (bl == br)
	{
		rep(i, l, r)
		{
			int tot = getNum(l, r, a[i]);
			if (tot > NUM || (tot == NUM && a[i] < ans))
			{
				ans = a[i];
				NUM = tot;
			}
		}
	}
	else
	{
		rep(i, l, b[bl].r)
		{
			int tot = getNum(l, r, a[i]);
			if (tot > NUM || (tot == NUM && a[i] < ans))
			{
				ans = a[i];
				NUM = tot;
			}
		}
		if (bl + 1 <= br - 1)
		{
			int v = f[bl + 1][br - 1];
			int tot = getNum(l, r, v);
			if (tot > NUM || (tot == NUM && v < ans))
			{
				ans = v;
				NUM = tot;
			}
		}
		rep(i, b[br].l, r)
		{
			int tot = getNum(l, r, a[i]);
			if (tot > NUM || (tot == NUM && a[i] < ans))
			{
				ans = a[i];
				NUM = tot;
			}
		}
	}
	return vv[ans - 1];
}

int main()
{
	sd(n);
	vv.clear();
	rep(i, 1, n)
	{
		sd(a[i]);
		vv.pb(a[i]);
	}
	sort(vv.begin(), vv.end());
	vv.erase(unique(vv.begin(), vv.end()), vv.end());
	rep(i, 1, n)
	{
		a[i] = lower_bound(vv.begin(), vv.end(), a[i]) - vv.begin() + 1;
	}
	rep(i, 0, vv.size())
	{
		pos[i].clear();
	}
	block = 30;
	rep(i, 1, n)
	{
		belong[i] = (i - 1) / block + 1;
		pos[a[i]].push_back(i);
	}
	rep(i,1,belong[n])
	{
		b[i].l = (i - 1) * block + 1;
		b[i].r = b[i].l + block - 1;
	}
	b[belong[n]].r = n;
	init();
	rep(i, 1, n)
	{
		int l, r;
		sdd(l,r);
		pd(query(l, r));
	}
	return 0;
}