【LOJ6482】LJJ 爱数数 数论

本文深入探讨了一道数学算法题目,该题目要求求解特定条件下涉及三个变量的三重求和问题。文章首先给出了题目的背景和要求,随后详细分析了题目的解题思路,包括利用数学变换简化原始表达式,以及通过枚举和筛选策略求解最大公约数等于1的条件。文章最后提供了两种解法的时间复杂度分析和对应的代码实现。

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

题目大意

  给你 \(n\),求
\[ \sum_{a=1}^n\sum_{b=1}^n\sum_{c=1}^n[\frac{1}{a}+\frac{1}{b}=\frac{1}{c}][\gcd(a,b,c)=1]\\ \]
  \(n\leq {10}^{12}\)

题解

\[ \begin{align} &\sum_{a=1}^n\sum_{b=1}^n\sum_{c=1}^n[\frac{1}{a}+\frac{1}{b}=\frac{1}{c}][\gcd(a,b,c)=1]\\ =&\sum_{a=1}^n\sum_{b=1}^n\sum_{c=1}^n[c(a+b)=ab][\gcd(a,b,c)=1]\\ =&\sum_{a=1}^n\sum_{b=1}^n[(a+b)\mid ab][\gcd(a,b,c)=1]\\ \end{align} \]

  通过打表可以发现,一对数 \(a,b(a\leq b)\) 满足条件的充要条件是 \(b\leq n\)\(\frac{a}{\gcd(a,b)}+\frac{b}{\gcd(a,b)}=\gcd(a,b)\)

  证明:

  若 \(\gcd(a,b)=1\),则 \(\gcd(a+b,ab)=1\)

  记 \(g=\gcd(a,b),a=ga',b=gb'\),则
\[ a+b=g(a'+b')\\ ab=g^2a'b'\\ \frac{ab}{a+b}=\frac{g^2a'b'}{g(a'+b')}=\frac{ga'b'}{a'+b'}\\ \]
  所以 \((a'+b')\mid g\)

  若 \(a'+b'\neq g\),则 \(\gcd(a,b,c)=\frac{g}{a'+b'}\),所以 \(a'+b'=g\) 所以 \(a=a'(a'+b'),b=b'(a'+b'),c=a'b'\)

解法一

  记 \(x=a',y=b'\)
\[ \begin{align} ans&=\sum_{x=1}^n\sum_{y=x}^n[xy+y^2\leq n]\gcd(x,y)=1\\ &=\sum_{d=1}^\sqrt{n}\mu(d)\sum_{x=1}\sum_{y=x}[xy+y^2\leq \frac{n}{d^2}]\\ &=\sum_{d=1}^\sqrt{n}\mu(d)\sum_{y=1}\min\left(\left\lfloor\frac{\left\lfloor\frac{n}{d^2}\right\rfloor-y^2}{y}\right\rfloor,y\right) \end{align} \]
  时间复杂度:\(O(\sqrt n\log n)\)

解法二

  \(a+b=g^2\)

  枚举 \(g\),那么 \(\gcd(g,a')=1\)

  当 \(g\) 比较小的时候 \((1\leq g\leq \sqrt n)\)\(a'\)\(\varphi(g)\) 种取值,可以直接筛

  当 \(g\) 比较大的时候 \((\sqrt n<g<\sqrt{2n})\)
\[ \sum_{i=1}^\frac{n}{g}[\gcd(g,i)=1]\\ =\sum_{d\mid g}\mu(d)\lfloor\frac{n}{gd}\rfloor \]
  可以暴力枚举因子。

  时间复杂度:\(O(\sqrt n\log n)\)

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<ctime>
#include<utility>
#include<functional>
#include<cmath>
#include<vector>
//using namespace std;
using std::min;
using std::max;
using std::swap;
using std::sort;
using std::reverse;
using std::random_shuffle;
using std::lower_bound;
using std::upper_bound;
using std::unique;
using std::vector;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef std::pair<int,int> pii;
typedef std::pair<ll,ll> pll;
void open(const char *s){
#ifndef ONLINE_JUDGE
    char str[100];sprintf(str,"%s.in",s);freopen(str,"r",stdin);sprintf(str,"%s.out",s);freopen(str,"w",stdout);
#endif
}
void open2(const char *s){
#ifdef DEBUG
    char str[100];sprintf(str,"%s.in",s);freopen(str,"r",stdin);sprintf(str,"%s.out",s);freopen(str,"w",stdout);
#endif
}
int rd(){int s=0,c,b=0;while(((c=getchar())<'0'||c>'9')&&c!='-');if(c=='-'){c=getchar();b=1;}do{s=s*10+c-'0';}while((c=getchar())>='0'&&c<='9');return b?-s:s;}
void put(int x){if(!x){putchar('0');return;}static int c[20];int t=0;while(x){c[++t]=x%10;x/=10;}while(t)putchar(c[t--]+'0');}
int upmin(int &a,int b){if(b<a){a=b;return 1;}return 0;}
int upmax(int &a,int b){if(b>a){a=b;return 1;}return 0;}
int gcd(int a,int b)
{
    return b?gcd(b,a%b):a;
}
int check(int x,int y)
{
    return x*y%(x+y)==0;
}
const int N=1000010;
int b[N];
int pri[N];
int miu[N];
int cnt;
int main()
{
//  open("loj6482");
    ll n;
    scanf("%lld",&n);
    miu[1]=1;
    for(int i=2;i<=1000000;i++)
    {
        if(!b[i])
        {
            pri[++cnt]=i;
            miu[i]=-1;
        }
        for(int j=1;j<=cnt&&i*pri[j]<=1000000;j++)
        {
            b[i*pri[j]]=1;
            if(i%pri[j]==0)
                break;
            miu[i*pri[j]]=-miu[i];
        }
    }
    ll ans=0;
    for(int i=1;(ll)i*i<=n;i++)
        if(miu[i])
        {
            ll s=0;
            for(int j=1;;j++)
            {
                int z=min((n/i/i-(ll)j*j)/j,(ll)j);
                if(z<=0)
                    break;
                s+=z;
            }
            ans+=miu[i]*s;
        }
    ans=ans*2-1;
    printf("%lld\n",ans);
//  int ans=0;
//  for(int i=1;i<=n;i++)
//      for(int j=1;j<=n;j++)
//          if(gcd(i,j)==1&&i*(i+j)<=n&&j*(i+j)<=n)
//              ans++;
//  printf("%d\n",ans);
//  return 0;
//  int n=1000;
//  for(int i=1;i<=n;i++)
//      for(int j=i;j<=n;j++)
//          if(gcd(i,j)==1&&check(i*(i+j),j*(i+j))&&gcd(gcd(i*(i+j),j*(i+j)),i*j)==1)
//              if(j*(i+j)<=n)
//                  printf("%d %d %d\n",i*(i+j),j*(i+j),i*j);
//  return 0;
//  for(int i=1;i<=n;i++)
//      for(int j=i;j<=n;j++)
//          if(i*j%(i+j)==0)
//          {
//              int z=i*j/(i+j);
//              if(gcd(gcd(i,j),z)==1)
//                  printf("%d %d %d %d %d %d\n",i,j,z,gcd(i,j),i/gcd(i,j),j/gcd(i,j));
//          }
//  return 0;
}

转载于:https://www.cnblogs.com/ywwyww/p/9832481.html

06-21
<think>我们正在查询LOJ6279相关的编程题目或解决方案。LOJ(LibreOJ)是一个在线的评测系统,主要收录算法竞赛题目。根据题号6279,我们需要确定该题目的具体内容。由于我无法直接访问网络,我将基于已知信息进行推理。在算法竞赛中,LOJ的题目编号通常特定的题目对应。题号6279可能对应一个特定的问题。根据常见的题目类型,我们可以推测它可能涉及数据结构算法。然而,为了准确回答,我们可以尝试回忆或推断常见的LOJ题目。例如,LOJ6000系列题目多为数据结构题,如线段树、树状组等。实际上,通过搜索记忆,我回想起LOJ6279是“列分块入门3”(BlockArray3)题目。这是“分块”系列题目中的一题。题目描述:给出一个长为n的列,以及n个操作,操作涉及区间加法,询问区间内小于某个值x的前驱(即最大的小于x的)。因此,用户需要的是关于LOJ6279题目的描述和解决方案。解决方案:由于题目要求分块处理,我们将列分成若干块,每块大小为sqrt(n)。对于每个块,我们维护一个有序的组(用于二分查找)以及一个加法标记(记录整个块被加了多少)。操作:1.区间加法:对于整块,直接更新加法标记;对于不完整的块,暴力更新元素值,然后重新排序该块(或者重新构建有序组)。2.查询区间内小于x的前驱:遍历区间内的所有块。对于整块,在块的有序组中二分查找小于(x-加法标记)的最大值;对于不完整的块,暴力遍历每个元素,判断是否小于x(注意加上加法标记)并更新最大值。代码实现(C++)示例:```cpp#include<iostream>#include<vector>#include<cmath>#include<algorithm>#include<climits>usingnamespacestd;constintMAXN=100010;constintBLOCK_SIZE=320;//约sqrt(MAXN)intn;vector<int>a;vector<int>block_add;//每块的加法标记vector<vector<int>>sorted_blocks;//每块的有序组voidinit(){intblock_num=(n+BLOCK_SIZE-1)/BLOCK_SIZE;block_add.assign(block_num,0);sorted_blocks.resize(block_num);for(inti=0;i<n;i++){sorted_blocks[i/BLOCK_SIZE].push_back(a[i]);}for(inti=0;i<block_num;i++){sort(sorted_blocks[i].begin(),sorted_blocks[i].end());}}voidupdate_block(intblock_id){sorted_blocks[block_id].clear();intstart=block_id*BLOCK_SIZE;intend=min((block_id+1)*BLOCK_SIZE,n);for(inti=start;i<end;i++){sorted_blocks[block_id].push_back(a[i]);}sort(sorted_blocks[block_id].begin(),sorted_blocks[block_id].end());}voidadd(intl,intr,intc){intblock_l=l/BLOCK_SIZE,block_r=r/BLOCK_SIZE;if(block_l==block_r){for(inti=l;i<=r;i++){a[i]+=c;}update_block(block_l);}else{for(inti=l;i<(block_l+1)*BLOCK_SIZE;i++){a[i]+=c;}update_block(block_l);for(inti=block_l+1;i<block_r;i++){block_add[i]+=c;}for(inti=block_r*BLOCK_SIZE;i<=r;i++){a[i]+=c;}update_block(block_r);}}intquery(intl,intr,intc){intblock_l=l/BLOCK_SIZE,block_r=r/BLOCK_SIZE;intans=-1;if(block_l==block_r){for(inti=l;i<=r;i++){intval=a[i]+block_add[block_l];if(val<c){if(val>ans)ans=val;}}}else{for(inti=l;i<(block_l+1)*BLOCK_SIZE;i++){intval=a[i]+block_add[block_l];if(val<c){if(val>ans)ans=val;}}for(inti=block_l+1;i<block_r;i++){//在块i的有序组中二分查找小于c-block_add[i]的最大值inttarget=c-block_add[i];autoit=lower_bound(sorted_blocks[i].begin(),sorted_blocks[i].end(),target);if(it!=sorted_blocks[i].begin()){it--;intval=*it+block_add[i];if(val>ans)ans=val;}}for(inti=block_r*BLOCK_SIZE;i<=r;i++){intval=a[i]+block_add[block_r];if(val<c){if(val>ans)ans=val;}}}returnans;}intmain(){cin>>n;a.resize(n);for(inti=0;i<n;i++){cin>>a[i];}init();for(inti=0;i<n;i++){intop,l,r,c;cin>>op>>l>>r>>c;l--;r--;//如果题目输入是1-indexed,则转换为0-indexedif(op==0){add(l,r,c);}else{cout<<query(l,r,c)<<endl;}}return0;}```注意:上述代码是示例代码,可能需要根据题目具体输入要求进行调整。§§相关问题§§1.LOJ6279题目的具体描述是什么?2.分块算法的时间复杂度是多少?3.除了分块,还有哪些方法可以解决LOJ6279?4.如何优化分块算法的常?5.分块算法适用于哪些场景?</think>### LOJ 6279 题目分析解决方案 **题目描述**:LOJ 6279 是 LibreOJ 上的 **"列分块入门 3"**,属于分块算法的经典练习题。核心要求如下: - **操作 1**:区间 $[l, r]$ 内每个加上值 $c$ - **操作 2**:查询区间 $[l, r]$ 内小于 $c$ 的**最大元素值**(即前驱),不存在时返回 $-1$ #### 分块算法设计 分块的核心思想是将列划分为 $\sqrt{n}$ 大小的块,平衡暴力操作批量处理。 ##### 关键数据结构 1. **块内有序组**: - 每块维护一个排序后的组,用于二分查找前驱。 - 示例:块 $B_i$ 的排序组为 $S_i$。 2. **加法懒标记**: - 记录整块被加的总值 $add_i$(不影响块内有序性)。 ##### 操作实现 1. **区间加法($[l, r] + c$)**: - **整块**:直接更新懒标记 $add_i \gets add_i + c$,时间复杂度 $O(1)$。 - **碎块**:暴力修改元素值,并**重构有序组**(排序),时间复杂度 $O(\sqrt{n} \log \sqrt{n})$。 2. **查询前驱($[l, r]$ 内 $< c$ 的最大值)**: - **整块**:在有序组 $S_i$ 中二分查找 $c - add_i$ 的前驱,时间复杂度 $O(\log \sqrt{n})$。 - **碎块**:暴力遍历元素,检查 $a_j + add_i < c$ 并更新最大值,时间复杂度 $O(\sqrt{n})$。 #### 代码实现(C++) ```cpp #include <iostream> #include <vector> #include <cmath> #include <algorithm> #include <climits> using namespace std; const int MAXN = 100010; int n, block_size; vector<int> a; vector<int> add_tag; // 块的加法标记 vector<vector<int>> blocks; // 每块的有序组 void init() { block_size = sqrt(n); int block_num = (n + block_size - 1) / block_size; add_tag.assign(block_num, 0); blocks.resize(block_num); for (int i = 0; i < n; i++) blocks[i / block_size].push_back(a[i]); for (int i = 0; i < block_num; i++) sort(blocks[i].begin(), blocks[i].end()); } void rebuild_block(int block_id) { blocks[block_id].clear(); int start = block_id * block_size; int end = min(start + block_size, n); for (int i = start; i < end; i++) blocks[block_id].push_back(a[i]); sort(blocks[block_id].begin(), blocks[block_id].end()); } void range_add(int l, int r, int c) { int block_l = l / block_size, block_r = r / block_size; if (block_l == block_r) { // 同一块内 for (int i = l; i <= r; i++) a[i] += c; rebuild_block(block_l); } else { // 左侧碎块 for (int i = l; i < (block_l + 1) * block_size; i++) a[i] += c; rebuild_block(block_l); // 中间整块 for (int i = block_l + 1; i < block_r; i++) add_tag[i] += c; // 右侧碎块 for (int i = block_r * block_size; i <= r; i++) a[i] += c; rebuild_block(block_r); } } int query_predecessor(int l, int r, int c) { int ans = -1; int block_l = l / block_size, block_r = r / block_size; // 左侧碎块暴力查询 for (int i = l; i < min(r + 1, (block_l + 1) * block_size); i++) { int val = a[i] + add_tag[block_l]; if (val < c && val > ans) ans = val; } // 中间整块二分查找 for (int i = block_l + 1; i < block_r; i++) { int target = c - add_tag[i]; auto it = lower_bound(blocks[i].begin(), blocks[i].end(), target); if (it != blocks[i].begin()) { it--; int val = *it + add_tag[i]; if (val < c && val > ans) ans = val; } } // 右侧碎块暴力查询 if (block_l != block_r) { for (int i = block_r * block_size; i <= r; i++) { int val = a[i] + add_tag[block_r]; if (val < c && val > ans) ans = val; } } return ans; } int main() { cin >> n; a.resize(n); for (int i = 0; i < n; i++) cin >> a[i]; init(); for (int i = 0; i < n; i++) { int op, l, r, c; cin >> op >> l >> r >> c; l--; r--; // 转为0-indexed if (op == 0) range_add(l, r, c); else cout << query_predecessor(l, r, c) << endl; } return 0; } ``` #### 算法分析 - **时间复杂度**: - 单次修改/查询:$O(\sqrt{n} \log \sqrt{n})$(碎块排序主导)。 - 总操作 $m$ 次:$O(m \sqrt{n} \log n)$。 - **空间复杂度**:$O(n)$。 #### 优化技巧 1. **减少排序次**: - 碎块修改时只重构受影响块的有序组。 2. **块大小调整**: - 实测调整块大小为 $n^{0.6}$ 可能更快(需测试)。 #### 应用场景 分块算法适用于**强制在线**的区间问题(如 LOJ列分块系列题),在 $O(\sqrt{n})$ 复杂度下平衡修改查询[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值