一种解决区间计数问题的方法

介绍一种可以在线性带log的时间复杂度下统计具有某种性质的区间数量的技巧

这类问题一般有一种特性：需要计算的区间很多，但对于某一固定左(右)端点，其所有区间中的有效值很少，且这些值具有连续性(比如像1,1,1,2,2,3,3,3,3这样)，便可以通过这种方法进行统计

直接上例题

Problem - D - Codeforces

题目大意：多次询问x，每次查询所有区间中gcd==x的区间数量

显然这道题很符合上面说的特性，即对于某一固定的左端点，所有的区间中的gcd值很少(log级别)

且随着右端点的右移，区间gcd大小只减少不增加

我们直接上算法

首先重点介绍算法的核心

struct pp
{
	int val;
	int l,r;
}orz[N];

就是这个结构体数组，它的含义是对于当前左端点的区间中gcd值为val的右端点所在的位置是[l,r]（因为对于同一左端点gcd的值具有单调性，因此gcd相同的区间右端点一定是连续的）

 这是枚举左端点为2的时候的orz数组，可以看出当前orz数组的长度为4(即为颜色个数)

orz[1]={8, 2, 3}

orz[2]={4, 4, 4}

orz[3]={2, 5, 7}

orz[4]={1, 8, 11}

那么我们只需在每一次对于当前左端点更新orz数组之后枚举orz数组然后用map累加一下当前val的数量

for(int j=1; j<=cnt; j++)
	ans[orz[j].val]+=orz[j].r-orz[j].l+1; // 记录上当前以i为左端点的区间gcd答案

怎样在更换左端点时维护orz数组呢？

我们考虑从后往前枚举区间左端点，那么对于当前新的左端点i我们的orz数组其实就是对上一次的orz数组遍历一遍将里面所有的val都与当前值a[i]取一遍gcd就可以了，当然还要再加入a[i]单独做一个区间，之后orz数组中可能会出现重复的val(4和8对5取gcd都为1)，我们要合并这些val相同的区间，以此保证orz数组的大小始终为log级别

orz[++cnt]={a[i], i, i};// 加入新的数  orz中的存储顺序从前往后 因此元素是升序的(gcd不会变大)
orz[1].val=gcd(orz[1].val, a[i]);
int k=1;
for(int j=2; j<=cnt; j++)
{
	orz[j].val=gcd(orz[j].val, a[i]);
	if(orz[j].val==orz[k].val) // 去重
		orz[k].l=orz[j].l; // 维护相同gcd的区间 --> i与[l, r]之间任何一个点形成的区间gcd都为val
	else
		orz[++k]=orz[j];
}
cnt=k;

最后询问的时候直接输出ans[x]就可以了

#include <iostream>
#include <map>
using namespace std;
const int N=100005;
int a[N];   
struct pp    
{
	int val;
	int l,r;
}orz[N];
map<int, long long>ans,vis;
int gcd(int x, int y)
{
	return y==0 ? x : gcd(y, x%y);
}
int main()
{
	int n; scanf("%d", &n);
	for(int i=1; i<=n; i++) scanf("%d", &a[i]);
	int cnt=0;
	for(int i=n; i>=1; i--) // 倒序遍历 也可以正序遍历
	{
		orz[++cnt]={a[i], i, i};// 加入新的数  orz中的存储顺序从前往后 因此元素是升序的(gcd不会变大)
		orz[1].val=gcd(orz[1].val, a[i]);
		int k=1;
		for(int j=2; j<=cnt; j++)
		{
			orz[j].val=gcd(orz[j].val, a[i]);
			if(orz[j].val==orz[k].val) // 去重
				orz[k].l=orz[j].l; // 维护相同gcd的区间 --> i与[l, r]之间任何一个点形成的区间gcd都为val
			else
				orz[++k]=orz[j];
		}
		cnt=k;
		for(int j=1; j<=cnt; j++)
			ans[orz[j].val]+=orz[j].r-orz[j].l+1; // 记录上当前以i为左端点的区间gcd答案
	}
	int q; scanf("%d", &q);
	while(q--)
	{
		int x; scanf("%d", &x);
		cout << ans[x] << '\n';
	}
	return 0;
}

时间复杂度O(n * log val^2) val是元素大小

此做法可扩展至求区间或、区间与、区间加 等

https://codeforces.com/contest/1632/problem/D

题目大意：每次操作可以把一个位置的数修改为任一正整数，对于数组每个前缀计算使其所有子数组中不存在区间长度==区间gcd的最少修改次数

同样的区间gcd，注意修改完数后把orz数组清空就好了

#include <iostream>
using namespace std;

const int N=200005;
int a[N];
struct pp
{
	int val;
	int l, r;
}orz[N];
int gcd(int x, int y)
{
	return y==0 ? x : gcd(y, x%y);
}
int main()
{
	int n; scanf("%d", &n);
	for(int i=1; i<=n; i++) scanf("%d", &a[i]);
	int cnt=0,ans=0;
	for(int i=1; i<=n; i++) // 正序遍历 题目要求前缀
	{
		orz[++cnt]={a[i], i, i}; // 加入新的数
		if(a[i]==1)
		{
			cout << ++ans << ' ';
			cnt=0; // 当前位置必须要更改 考虑变为当前最大的质数 那么前面所有的数与[i+1, n]之间的区间gcd一定为1 可以把orz数组清空
			continue;
		}
		for(int j=1; j<=cnt; j++)
			orz[j].val=gcd(orz[j].val, a[i]);
		int k=0;
		for(int j=1; j<=cnt; j++) // 去重
		{
			if(k && orz[k].val==orz[j].val)
				orz[k].r=orz[j].r; // 正序遍历维护的是右端点
			else
				orz[++k]=orz[j];
		}
		cnt=k;
		for(int j=1; j<=cnt; j++) // 遍历orz数组
		{
			int pos=i-orz[j].val+1;
			if(pos>=orz[j].l && pos<=orz[j].r) // i与[l, r]之间任何一个点形成的区间gcd都为val 若pos落在该范围内
			{                                  // 则说明存在区间长度==区间gcd
				ans++; // 把这个位置的数修改为大质数 前面的可以不用再统计
				cnt=0; // 清除orz数组
				break;
			}
		}
		cout << ans << ' ';
	}
	return 0;
}

时间复杂度O(n * log val)

https://www.dotcpp.com/oj/problem2622.html

2021年第十二届蓝桥杯国赛真题

给定一个数列 A = (a1, a2, · · · , an)，问有多少个区间 [L, R] 满足区间内元素的乘积等于他们的和，即 aL · aL+1 · · · aR = aL + aL+1 + · · · + aR 。

 就是问乘积==和的区间数量

这里不是gcd了，但是我们注意到对于同一左端点的区间乘积只增不减，且乘积的大小一定不会超过数组的总和sum(超过了就不需要统计了)，考虑到这样的乘积的数量是log级别的，直接上模板

#include <iostream> /// docpp 2622 蓝桥杯2021国赛 和等于乘积的区间数量  O(n * log(sum))
using namespace std; // 累乘要么不变(乘1) 要么最少扩大两倍 --> 总后缀乘积数量保存log(sum)个即可

const int N=200005;
int a[N];
long long sum[N];
struct pp
{
	long long val;
	int l, r; // 记录当前 [i ~ [l, r]]区间内的乘积都为val
}orz[N];

int main()
{
	int n; scanf("%d", &n);
	for(int i=1; i<=n; i++) scanf("%d", &a[i]);
	for(int i=1; i<=n; i++)
		sum[i]=sum[i-1]+a[i];
	int cnt=0,ans=0;
	for(int i=n; i>=1; i--) // 倒序遍历
	{
		orz[++cnt]={1, i, i}; // 加入新的数
		for(int j=1; j<=cnt; j++)
			orz[j].val*=a[i];
		int k=0;
		for(int j=1; j<=cnt; j++) // 去重
		{
			if(orz[j].val<=sum[n])
			{
				if(k && orz[k].val==orz[j].val)
					orz[k].l=orz[j].l;
				else
					orz[++k]=orz[j];
			}
		}
		cnt=k;
		for(int j=1; j<=cnt; j++)
		{
			int l=orz[j].l,r=orz[j].r;
			if(sum[l]-sum[i-1]<=orz[j].val && sum[r]-sum[i-1]>=orz[j].val) // l~r之间的数都是1 且到i之间的累乘积为val
				ans++;                                                     // 判断是否存在idx使得sum[i~idx]==mul[i~idx]==val
		}                                                                  // 只需判断是否sum[i~l]<=val && sum[i~r]>=val即可
	}
	cout << ans << '\n';
	return 0;
}

时间复杂度还是O(n * log val)