洛谷P1447 [NOI2010]能量采 莫比乌斯反演+整除分块

本文深入解析洛谷P1447[NOI2010]能量采集问题,采用莫比乌斯反演和整除分块技术解决矩阵中所有点的特定花费总和问题。通过枚举gcd(i,j)并利用线筛预处理,实现高效算法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >


洛谷P1447 [NOI2010]能量采集


标签

  • 莫比乌斯反演
  • 整除分块

前言


简明题意

  • 给一个 n ∗ m n*m nm的矩阵,如果从 ( 0 , 0 ) 到 ( x , y ) (0,0)到(x,y) (0,0)(x,y)的连线上点的数量是 c n t cnt cnt(不包含 ( 0 , 0 ) , ( x , y ) (0,0),(x,y) (0,0),(x,y)),那么点 ( x , y ) (x,y) (x,y)的花费就是 2 ∗ c n t + 1 2*cnt +1 2cnt+1.问所有点的花费之和。

思路

  • ( 0 , 0 ) 到 ( x , y ) (0,0)到(x,y) (0,0)(x,y)连线上点的数量是 g c d ( x , y ) gcd(x,y) gcd(x,y)(包含 ( x , y ) (x,y) (x,y)),那么按照题意得 c n t cnt cnt就应该是 g c d ( x , y ) − 1 gcd(x,y)-1 gcd(x,y)1,那么所有点得贡献和就是:
    ∑ i = 1 n ∑ j = 1 m ( 2 ∗ ( g c d ( i , j ) − 1 ) + 1 ) \sum_{i=1}^n\sum_{j=1}^m\left(2*\left(gcd(i,j)-1\right)+1\right) i=1nj=1m(2(gcd(i,j)1)+1)
  • 提出常数,原式就变成:
    2 ∗ ∑ i = 1 n ∑ j = 1 m g c d ( i , j ) − n ∗ m 2*\sum_{i=1}^{n}\sum_{j=1}^mgcd(i,j)-n*m 2i=1nj=1mgcd(i,j)nm
  • 所以,现在的难点就在于如何求 ∑ i = 1 n ∑ j = 1 m g c d ( i , j ) \sum\limits_{i=1}^{n}\sum\limits_{j=1}^mgcd(i,j) i=1nj=1mgcd(i,j)。但这个实际很简单。我们改为枚举 g c d ( i , j ) gcd(i,j) gcd(i,j),就变成:
    ∑ x = 1 n ( x ∗ ∑ i = 1 n ∑ j = 1 m [ g c d ( i , j ) = = x ] ) \sum_{x=1}^n\left(x*\sum\limits_{i=1}^{n}\sum\limits_{j=1}^m[gcd(i,j)==x]\right) x=1n(xi=1nj=1m[gcd(i,j)==x])
  • ∑ i = 1 n ∑ j = 1 m [ g c d ( i , j ) = = x ] \sum\limits_{i=1}^{n}\sum\limits_{j=1}^m[gcd(i,j)==x] i=1nj=1m[gcd(i,j)==x]的求法在我的另一篇博客中详细说明了,请戳这里,我们现在直接把结论摆出来:
    ∑ i = 1 n ∑ j = 1 m [ g c d ( i , j ) = = x ] = ∑ d = 1 [ n x ] ( μ ( d ) ∗ [ n d x ] ∗ [ m d x ] ) \sum\limits_{i=1}^{n}\sum\limits_{j=1}^m[gcd(i,j)==x]=\sum_{d=1}^{[\frac nx]}\left( \mu(d)*[\frac {n}{dx}]*[\frac {m}{dx}]\right) i=1nj=1m[gcd(i,j)==x]=d=1[xn](μ(d)[dxn][dxm])
  • 再把这个带入原式,就得到了:
    ∑ i = 1 n ∑ j = 1 m g c d ( i , j ) = ∑ x = 1 n ( x ∗ ∑ d = 1 [ n x ] ( μ ( d ) ∗ [ n d x ] ∗ [ m d x ] ) ) \sum_{i=1}^{n}\sum_{j=1}^mgcd(i,j)=\sum_{x=1}^{n}\left(x*\sum_{d=1}^{[\frac nx]}\left( \mu(d)*[\frac {n}{dx}]*[\frac {m}{dx}]\right)\right) i=1nj=1mgcd(i,j)=x=1nxd=1[xn](μ(d)[dxn][dxm])
  • 预处理用线筛 O ( n ) O(n) O(n) x x x的枚举是 O ( n ) O(n) O(n),后面那一坨可以整除分块,复杂度 O ( n x ) O(\sqrt{\frac nx}) O(xn )。上面式子的复杂度是 O ( n + n ∗ n x ) O(n+n*\sqrt{\frac nx}) O(n+nxn ),就是 O ( n ∗ n x ) O(n*\sqrt{\frac nx}) O(nxn )

注意事项


总结

  • ( 0 , 0 ) (0,0) (0,0) ( x , y ) (x,y) (x,y)连线上点的数量是 g c d ( x , y ) gcd(x,y) gcd(x,y),包含 ( x , y ) 但 不 包 含 ( 0 , 0 ) (x,y)但不包含(0,0) (x,y)(0,0)

AC代码

#include<cstdio>
#include<algorithm>
using namespace std;

const int maxn = 1e5 + 10;

int n, m;

bool no_prime[maxn];
int prime[maxn], mu[maxn], pre_mu[maxn];
int shai(int n)
{
   int cnt = 0;
   mu[1] = 1;

   for (int i = 2; i <= n; i++)
   {
   	if (!no_prime[i])
   		prime[++cnt] = i, mu[i] = -1;

   	for (int j = 1; j <= cnt && prime[j] * i <= n; j++)
   	{
   		no_prime[prime[j] * i] = 1;
   		mu[prime[j] * i] = i % prime[j] == 0 ? 0 : -mu[i];
   		if (i % prime[j] == 0) break;
   	}
   }

   for (int i = 1; i <= n; i++)
   	pre_mu[i] = pre_mu[i - 1] + mu[i];

   return cnt;
}

int cal2(int n, int m, int x)
{
   n = n / x, m = m / x;

   int l = 1, r, ans = 0;
   while (l <= n)
   {
   	r = min(n / (n / l), m / (m / l));
   	ans += (pre_mu[r] - pre_mu[l - 1]) * (n / l) * (m / l);
   	l = r + 1;
   }
   return ans;
}


void solve()
{
   scanf("%d%d", &n, &m);
   if (m < n) swap(n, m);
   shai(m);

   long long ans = 0;
   for (int x = 1; x <= n; x++)
   	ans += 1ll * x * cal2(n, m, x);

   printf("%lld", 2 * ans - n * m);
}

int main()
{
   solve();
   return 0;
}
<think>嗯,用户想了解如何用分块方法解决洛谷P2042这个维护数列的问题。首先,我需要回忆一下分块算法的基本概念。分块通常是将数据分成多个块,每个块单独处理,平衡查询和修改的时间复杂度。不过,题目是NOI2005的,可能比较复杂,因为维护数列通常涉及插入、删除、区间修改、翻转、求和、最大子段和等操作。分块处理这些操作可能比较麻烦,尤其是动态的插入和删除,会导致块的大小变化,影响效率。 首先,我得确认分块是否适合这个问题。一般来说,分块的时间复杂度是O(n√n),对于大数可能还行,但像这种NOI题目可能数据量较大,分块可能不够高效,不过用户明确问分块方法,所以需要找到如何结构设计。 维护数列的典型操作包括:在某个位置插入一段数列,删除某个区间,区间覆盖,区间翻转,区间求和,求最大子段和。分块的话,每个块需要维护这些操作的信息。比如每个块需要记录翻转标记、覆盖标记,以及各种区间和、最大子段和等。 接下来,分块的结构设计。每个块可以存储一个数组,同时维护块内的总和、最大前缀和、最大后缀和、最大子段和,以及翻转和覆盖的懒标记。插入和删除操作需要考虑块的分裂和合并,这可能比较复杂,因为频繁的插入删除会导致块的大小不均,影响效率。所以可能需要设置块的大小阈值,比如当块的大小超过2√n时分裂,小于√n/2时合并相邻块。 处理翻转操作时,每个块维护一个翻转标记,当需要翻转区间时,对覆盖的完整块标记翻转,并处理部分块。同样,覆盖操作需要懒标记,当块被完全覆盖时,直接更新块内的值,并记录覆盖值。 最大子段和的计算需要每个块维护内部的最大子段和、最大前缀和、最大后缀和,这样在查询时,可以将多个块的信息合并起来得到整体的最大子段和。这可能比较复杂,需要考虑块之间的前后缀如何组合。 插入和删除操作需要找到对应的位置所在的块,如果插入导致块过大,就分裂成两个块。删除时如果块变得过小,可能需要合并相邻块。这些操作需要维护块之间的链表结构,方便快速插入和删除块。 举个例子,当要在位置pos插入一段数列,首先找到pos所在的块,如果块的大小加上插入元素后超过阈值,就分裂该块为两个,然后将插入的元素作为新块插入到链表中。这样插入的时间复杂度是O(√n),因为分裂和插入块的时间与块的大小有关。 对于翻转和覆盖操作,应用懒标记是关键,这样可以延迟实际的操作,直到需要访问块的具体内容时才进行实际的处理。例如,当需要访问一个带有翻转标记的块时,先执行翻转操作,并清除标记。 不过分块在处理这些动态操作时,尤其是频繁的插入和删除,可能效率不如平衡树结构(如Splay或Treap),但分块实现起来可能相对简单一些。需要权衡实现复杂度和效率。 总结一下,分块实现的关键点包括: 1. 分块的结构设计,每个块维护必要的信息和懒标记。 2. 插入和删除时的块分裂与合并策略。 3. 懒标记的处理,如翻转和覆盖,何时下传。 4. 查询操作时如何合并各个块的信息,如最大子段和。 可能遇到的问题包括块的大小管理不当导致性能下降,懒标记处理错误导致数据不一致,以及在合并块信息时逻辑错误。需要详细设计每个操作的步骤,并处理各种边界情况,比如操作区间跨多个块,或者在块的开头或结尾的部分操作。 最后,参考用户提供的引用,尤其是引用[1]提到递归图的理解,可能分块的递归处理不太相关,但引用[2]提到洛谷题目,可能需要参考类似题解中的分块实现方法。不过用户提供的引用可能没有直接相关的内容,所以需要依靠已有的分块知识来构建解决方案。</think>### 分块方法实现洛谷 P2042 维护数列问题 #### 分块结构设计 1. **块内信息**: - 数据存储:每个块存储$size \leq 2\sqrt{n}$个元素 - 维护以下字段: ```text sum: 区间和 lmax: 最大前缀和 rmax: 最大后缀和 tmax: 最大子段和 rev: 翻转标记(0/1) cov: 覆盖标记(特殊值表示未覆盖) ``` 2. **分块逻辑**: - 块间通过链表或数组连接 - 插入/删除时动态调整块大小,触发分裂或合并(例如块大小超过$2\sqrt{n}$时分裂,相邻块总大小低于$\sqrt{n}$时合并) #### 核心操作实现 **1. 区间翻转(REVERSE)**: - 对完整覆盖的块:翻转标记`rev ^= 1`,交换`lmax`与`rmax` - 对部分覆盖的块:下传标记后暴力翻转元素 时间复杂度:$O(\sqrt{n})$ **2. 区间覆盖(MAKE-SAME)**: - 对完整覆盖的块:更新`cov`标记,直接计算`sum`,`lmax`,`rmax`,`tmax` - 对部分覆盖的块:下传标记后暴力修改 时间复杂度:$O(\sqrt{n})$ **3. 最大子段和(MAX-SUM)**: - 合并相邻块的`rmax`和`lmax`,遍历所有块维护全局最大值 时间复杂度:$O(\sqrt{n})$ **4. 插入(INSERT)**: - 定位插入位置所在块,若插入后块大小超过阈值则分裂 时间复杂度:$O(\sqrt{n} + k/\sqrt{n})$ **5. 删除(DELETE)**: - 移除目标区间涉及的所有块,合并相邻小块 时间复杂度:$O(\sqrt{n} + k/\sqrt{n})$ #### 代码框架示例(关键部分) ```python class Block: def __init__(self): self.data = [] self.sum = 0 self.lmax = self.rmax = self.tmax = -inf self.rev = 0 self.cov = None def push_down(self): # 下传覆盖/翻转标记到数据层 if self.cov is not None: self.data = [self.cov] * len(self.data) if self.rev: self.data.reverse() self.rev = 0 self.cov = None def update_info(self): # 重新计算sum/lmax/rmax/tmax pass class BlockList: def __init__(self): self.blocks = [] def split(self, idx): # 分裂过大的块 pass def merge(self): # 合并过小的相邻块 pass ``` #### 复杂度分析 | 操作类型 | 时间复杂度 | |----------------|---------------------| | 插入/删除 | $O(\sqrt{n} + k)$ | | 翻转/覆盖/求和 | $O(\sqrt{n})$ | | 最大子段和 | $O(\sqrt{n})$ | #### 注意事项 1. **标记下传策略**:在访问块内数据前必须下传所有标记 2. **块大小平衡**:通过动态分裂/合并保证$size \in [\sqrt{n}/2, 2\sqrt{n}]$ 3. **边界处理**:特别注意区间跨多个块时的部分覆盖情况
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值