题目大意
给出一个长度为 n ( 1 ≤ n ≤ 1 e 5 ) n(1 \leq n \leq 1e5) n(1≤n≤1e5) 的序列 a i ( 1 ≤ a i ≤ 1 e 5 ) a_i (1 \leq a_i \leq 1e5) ai(1≤ai≤1e5)。给出 q ( 1 ≤ q ≤ 1 e 5 ) q(1 \leq q \leq 1e5) q(1≤q≤1e5) 次询问,每次询问给出区间的左右端点 l , r l,r l,r,问这个区间最少被分为多少个子数组,使得每个子数组中每个数的乘积都恰好等于他们的 l c m lcm lcm。
解题思路
第一个需要解决的问题是,给定一个区间如何去分?不难想到肯定是贪心的向后选,直到选到一个数和上一段数的乘积不等于公倍数,然后另起一段区间。暴力贪心肯定不行,可以用类似链表的思想,记录每个数右边第一个不互质数的位置 N e x t [ i ] Next[i] Next[i],每次跳到这个位置代表需要重新一段子数组;但是最终需要的是一段区间能向右延伸的最小位置,从右向左更新一遍这个位置就可以了,即每次和右边相邻的数能跳的最远位置取最小 N e x t [ i ] = m i n ( N e x t [ i ] , N e x t [ i + 1 ] ) Next[i] = min(Next[i], Next[i + 1]) Next[i]=min(Next[i],Next[i+1])。
维护好这个东西之后,只需要从左端点向右跳,优化了跳跃的复杂度。但是最坏的情况下,若所有数都是偶数,那么每次只能跳一个位置,这样仍是暴力的复杂度!
考虑使用类似ST表那样的倍增优化:设 d [ i ] [ j ] ( 1 ≤ i ≤ n , 2 j ≤ n ) d[i][j]( 1 \leq i \leq n, 2^j \leq n) d[i][j](1≤i≤n,2j≤n) 表示从位置 i i i 向后跳 2 j 2^j 2j 次能到达的位置,初始化 d [ i ] [ 0 ] = N e x t [ i ] d[i][0] = Next[i] d[i][0]=Next[i];状态转移方程为 d [ i ] [ j ] = d [ d [ i ] [ j − 1 ] ] [ j − 1 ] d[i][j] = d[d[i][j-1]][j - 1] d[i][j]=d[d[i][j−1]][j−1] 。预处理之后就能 O ( l o g n ) O(logn) O(logn) 查询了,每次从当前起点 l l l 跳跃最大的 2 k 2^k 2k,更新 l = d [ l ] [ k ] l = d[l][k] l=d[l][k],直到跳出 r r r。
因为若最远位置已经超过 n n n,要设置为 n + 1 n + 1 n+1,于是DP时位置要考虑到 [ 1 , n + 1 ] [1,n+1] [1,n+1]。
#include <bits/stdc++.h>
using namespace std;
#define ENDL "\n"
typedef long long ll;
const int Mod = 1e9 + 7;
const int maxn = 1e5 + 10;
int n;
int d[maxn][20];
int a[maxn], minp[maxn], Next[maxn];
vector<int> prime, pos[maxn];
void euler() {
for (int i = 1; i < maxn; i++) minp[i] = i;
for (int i = 2; i < maxn; i++) {
if (minp[i] == i) prime.push_back(i);
for (int j = 0; j < prime.size() && i * prime[j] < maxn; j++) {
minp[i * prime[j]] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
void divide(int x, int idx) {
if (x == 1) return;
set<int> s;
while (x > 1) {
s.insert(minp[x]);
x /= minp[x];
}
for (auto i : s) pos[i].push_back(idx);
}
void cal(int x, int idx) {
if (x == 1) {
Next[idx] = n + 1;
return;
}
set<int> s;
while (x > 1) {
s.insert(minp[x]);
x /= minp[x];
}
int ans = n + 1;
for (auto i : s) {
auto cur = upper_bound(pos[i].begin(), pos[i].end(), idx);
if (cur != pos[i].end()) ans = min(ans, *cur);
}
Next[idx] = ans;
}
void init() {
d[n + 1][0] = n + 1;
for (int i = n; i >= 1; i--) {
d[i][0] = Next[i];
d[i][0] = min(d[i + 1][0], d[i][0]);
}
// for (int i = 1; i <= n; i++) cout << d[i][0] << ' ';
// cout << endl;
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= n + 1; i++) {
d[i][j] = d[d[i][j - 1]][j - 1];
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int q;
euler();
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
divide(a[i], i);
}
for (int i = 1; i <= n; i++) cal(a[i], i);
init();
int l, r;
while (q--) {
cin >> l >> r;
int ans = 0;
for (int j = 19; j >= 0; j--) {
if (d[l][j] <= r) {
ans += (1 << j);
l = d[l][j];
}
}
cout << ans + 1 << ENDL;
}
return 0;
}
标答的 N e x t Next Next的初始化更奇妙,需要学一手!
#include <bits/stdc++.h>
using namespace std;
#define ENDL "\n"
typedef long long ll;
const int Mod = 1e9 + 7;
const int maxn = 1e5 + 10;
int n;
int d[maxn][20];
int a[maxn], Next[maxn];
vector<int> p[maxn];
void init() {
for (int i = 2; i < maxn; i++) {
if (!p[i].size()) {
Next[i] = n + 1;
for (int j = i; j < maxn; j += i) p[j].push_back(i);
}
}
d[n + 1][0] = n + 1;
for (int i = n; i >= 1; i--) {
d[i][0] = d[i + 1][0];
for (auto j : p[a[i]]) {
d[i][0] = min(d[i][0], Next[j]);
Next[j] = i;
}
}
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= n + 1; i++) {
d[i][j] = d[d[i][j - 1]][j - 1];
}
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int q;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
init();
int l, r;
while (q--) {
cin >> l >> r;
int ans = 0;
for (int j = 19; j >= 0; j--) {
if (d[l][j] <= r) {
ans += (1 << j);
l = d[l][j];
}
}
cout << ans + 1 << ENDL;
}
return 0;
}