codeforces 1516D Cut(倍增 | 双指针处理)

---

题目传送门：~~~

---

题目大意
n 个数，m次查询，每次查询区间内最少要划分为几个连续的段，使得每段所有数的乘积等于这些数的 lcm。

分析
如果一个数可以留在前一段，也可以放到后一段，放到前一段就不会影响到后一段，后一段就会有更多的选择。
对于每一次划分而言，划分成尽量长的序列是最优的选择。
因为要查询很多次，故而肯定要预处理，显然处理出来每一段的划分次数是不现实的，这里就要倍增了。我们处理出以当前为起点位置，划分2^k 次以后结束的位置。
每次查询从 l 开始查询到 r 结束 2^k 的和就是答案。
处理第一次划分的区间，那就要双指针了，嘿咻嘿咻~~

所有数的乘积等于这些数的 lcm，也就是这些数全部互质
证明：lcm(x, y) = x * y / gcd(x, y)，如果 lcm(x, y) = x * y，则 gcd(x,y) = 1

具体操作看代码~

AC代码

#include <bits/stdc++.h>
#include <stdio.h>
#include <vector>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <stack>
#define ll long long
#define chushi(a, b) memset(a, b, sizeof(a))
#define endl "\n"
const double eps = 1e-8;
const ll INF=0x3f3f3f3f;
const int mod=1e9 + 7;
const int maxn = 1e6 + 5;
const int N=1005;
using namespace std;

bool vis[maxn];
int mx[maxn]; // 存每个数的最大的质因子

void init(){ // 筛选出来每个数的最大的质因子
	for(int i = 2; i < maxn; i++){
		if(!vis[i]){
			for(int k = i; k + i < maxn; k += i){
				mx[k] = i;
				vis[k] = 1;
			}
		}
	}
}

int cnt = 0; // cnt 就是重复因子的个数
int col[maxn];
vector<int> v;
void add(int x){ // 在划分区间内增加这个数
	while(x != 1){ // 质因数分解
		v.push_back(mx[x]);
		x /= mx[x];
	}
	sort(v.begin(), v.end());
	int num = unique(v.begin(), v.end()) - v.begin(); // 去重，每个数的每个因子只记录一次
	for(int i = 0; i < num; i++){
		col[v[i]]++;
		if(col[v[i]] == 2) cnt++; // 如果某个因子之前出现过，就不互质了，重复的出现的因子数 +1 
	}
	v.clear();
}

void del(int x){ // 在划分区间内删掉这个数
	while(x != 1){
		v.push_back(mx[x]);
		x /= mx[x];
	}
	sort(v.begin(), v.end());
	int num = unique(v.begin(), v.end()) - v.begin();
	for(int i = 0; i < num; i++){
		col[v[i]]--;
		if(col[v[i]] == 1) cnt--;// 如果某个因子之前多次出现，现在就一个了，重复的出现的因子数 -1 

	}
	v.clear();
}

int a[maxn];
int f[maxn][22];

int main(){
	
	init();
	
	int n, m;
	cin >> n >> m;
	for(int i = 1; i <= n; i++) cin >> a[i];
	
	int s = n;
	for(int i = n; i >= 1; i--){
		add(a[i]);
		while(s >= i && cnt){ // 有重复因子，就要移动另一个指针了
			del(a[s]);
			s--;
		}
		f[i][0] = s+1;// 划分一次到达的新起点
	}
	
	for(int k = 1; (1 << k) <= n; k++){ // 倍增
		for(int i = 1; i <= n; i++){
			if(f[i][k-1] > n) f[i][k] = n+1; // 越过 n 了直接 n+1 即可
			else f[i][k] = f[f[i][k-1]][k-1];
		}
	}
	
	int l, r;
	while(m--){
		cin >> l >> r;
		int ans = 0;
		for(int k = 21; k >= 0; k--){ // 查询 
			if(f[l][k] <= r && f[l][k]){
				l = f[l][k]; // 每次都要更新 l 这样就可以保证 log(n) 的时间复杂度了
				ans += (1 << k);
			}
		}
		ans++; // 加上起止的一个区间
		cout << ans << endl;
	}
	
	return 0;
}