51Nod2026 Gcd and Lcm

本文探讨了一道关于数论函数的题目,揭示了f(gcd(x,y)) * f(lcm(x,y)) = f(x) * f(y)这一神奇结论,并通过积性函数的性质和莫比乌斯反演进行推导。通过引入狄利克雷卷积,展示了如何利用这一结论简化计算。" 106475998,7386347,Go语言字符类型与Unicode详解,"['Go语言编程', '字符编码', 'Unicode', '数据类型']


题目看这里
一个非常好的题!
好的,看到题目就很懵逼
首先这个f不就是 ϕ ϕ 吗,认真一看才发现不对
让后问题?f(lcm)*f(gcd)?
肯定有问题,推了一会没有结论,去看看题解:
有这么一个神奇结论 f(gcd(x,y))f(lcm(x,y))=f(x)f(y) f ( g c d ( x , y ) ) ∗ f ( l c m ( x , y ) ) = f ( x ) ∗ f ( y )
推导一下?大概就是这样:首先f是积性函数,那么
f(x)=Πki=1f(paii) f ( x ) = Π i = 1 k f ( p i a i )
同理
f(gcd(x,y))=Πki=1f(pmin(ai,bi)i) f ( g c d ( x , y ) ) = Π i = 1 k f ( p i m i n ( a i , b i ) )
f(lcm(x,y))=Πki=1f(pmax(ai,bi)i) f ( l c m ( x , y ) ) = Π i = 1 k f ( p i m a x ( a i , b i ) )
那么因为 max(a,b)+min(a,b)=a+b m a x ( a , b ) + m i n ( a , b ) = a + b
f(gcd(x,y))f(lcm(x,y))=Πki=1f(pai+bii)=f(x)f(y) f ( g c d ( x , y ) ) ∗ f ( l c m ( x , y ) ) = Π i = 1 k f ( p i a i + b i ) = f ( x ) ∗ f ( y )
所以原式变成了 (ni=1f(i))2 ( ∑ i = 1 n f ( i ) ) 2 是不是又可以杜教筛辣
别急,还有一步很精彩
我们要找一个函数和他做狄利克雷卷积
是不是发现f和 ϕ ϕ 很像?没错
(ϕf)(x)=d|xϕ(d)f(xd) ( ϕ ∗ f ) ( x ) = ∑ d | x ϕ ( d ) ∗ f ( x d )
=d|xϕ(d)i|xdiμ(i) = ∑ d | x ϕ ( d ) ∗ ∑ i | x d i ∗ μ ( i )
=id|xϕ(d)iμ(i) = ∑ i ∗ d | x ϕ ( d ) ∗ i ∗ μ ( i )
=i|xiμ(i)d|xiϕ(d) = ∑ i | x i ∗ μ ( i ) ∗ ∑ d | x i ϕ ( d )
=i|xiμ(i)xi = ∑ i | x i ∗ μ ( i ) ∗ x i
=xi|xμ(i)=[n=1] = x ∗ ∑ i | x μ ( i ) = [ n = 1 ]

剩下的部分参考杜教筛简易教程

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#include<map> 
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 10000010
#define LL long long
#define M 1000000007
using namespace std;
map<int,int> p,f; 
int n,phi[N],d[N],w[N>>3],t=0;
inline void init(){
    d[1]=phi[1]=1;
    for(int i=2;i<=10000000;++i){
        if(!phi[i]){ phi[w[++t]=i]=i-1; d[i]=1-i; }
        for(int j=1,k;j<=t && (k=i*w[j])<=10000000;++j){
            if(i%w[j]==0){ phi[k]=phi[i]*w[j]; d[k]=d[i]; break; }
            phi[k]=phi[i]*(w[j]-1); d[k]=d[i]*(1-w[j]);
        }
        phi[i]=(phi[i-1]+phi[i])%M; d[i]=(d[i-1]+d[i])%M;
    }
}
inline int gP(int x){
    if(x<=10000000) return phi[x];
    if(p.count(x)) return p[x];
    int s=((LL)x*(x+1)>>1)%M;
    for(int i=2,j;i<=x;i=j+1){
        j=x/(x/i);
        s=(s-gP(x/i)*(j-i+1ll)%M+M)%M;
    }
    return p[x]=s;
}
inline int gF(int x){
    if(x<=10000000) return d[x];
    if(f.count(x)) return f[x];
    LL s=1;
    for(int i=2,j;i<=x;i=j+1){
        j=x/(x/i);
        s=(s-gF(x/i)*((LL)gP(j)-gP(i-1)+M)%M+M)%M;
    }
    return f[x]=s;
}
int main(){
    scanf("%d",&n); init();
    printf("%d\n",(LL)gF(n)*gF(n)%M);
}
题目 51nod 3478 涉及一个矩阵问题,要求通过最少的操作次数,使得矩阵中至少有 `RowCount` 行和 `ColumnCount` 列是回文的。解决这个问题的关键在于如何高效地枚举所有可能的行和列组合,并计算每种组合所需的操作次数。 ### 解法思路 1. **预处理每一行和每一列变为回文所需的最少操作次数**: - 对于每一行,计算将其变为回文所需的最少操作次数。这可以通过比较每对对称位置的值是否相同来完成。 - 对于每一列,计算将其变为回文所需的最少操作次数,方法同上。 2. **枚举所有可能的行和列组合**: - 由于 `N` 和 `M` 的最大值为 8,因此可以枚举所有可能的行组合和列组合。 - 对于每一种组合,计算其所需的最少操作次数,并取最小值。 3. **计算操作次数**: - 对于每一种组合,需要计算哪些行和列需要修改,并且注意行和列的交叉点可能会重复计算,因此需要去重。 ### 代码实现 以下是一个可能的实现方式,使用了枚举和位运算来处理组合问题: ```python def min_operations_to_palindrome(matrix, row_count, col_count): import itertools N = len(matrix) M = len(matrix[0]) # Precompute the cost to make each row a palindrome row_cost = [] for i in range(N): cost = 0 for j in range(M // 2): if matrix[i][j] != matrix[i][M - 1 - j]: cost += 1 row_cost.append(cost) # Precompute the cost to make each column a palindrome col_cost = [] for j in range(M): cost = 0 for i in range(N // 2): if matrix[i][j] != matrix[N - 1 - i][j]: cost += 1 col_cost.append(cost) min_total_cost = float('inf') # Enumerate all combinations of rows and columns rows = list(range(N)) cols = list(range(M)) from itertools import combinations for row_comb in combinations(rows, row_count): for col_comb in combinations(cols, col_count): # Calculate the cost for this combination cost = 0 # Add row costs for r in row_comb: cost += row_cost[r] # Add column costs for c in col_comb: cost += col_cost[c] # Subtract the overlapping cells for r in row_comb: for c in col_comb: # Check if this cell is part of the palindrome calculation if r < N // 2 and c < M // 2: if matrix[r][c] != matrix[r][M - 1 - c] and matrix[N - 1 - r][c] != matrix[N - 1 - r][M - 1 - c]: cost -= 1 min_total_cost = min(min_total_cost, cost) return min_total_cost # Example usage matrix = [ [0, 1, 0], [1, 0, 1], [0, 1, 0] ] row_count = 2 col_count = 2 result = min_operations_to_palindrome(matrix, row_count, col_count) print(result) ``` ### 代码说明 - **预处理成本**:首先计算每一行和每一列变为回文所需的最少操作次数。 - **枚举组合**:使用 `itertools.combinations` 枚举所有可能的行和列组合。 - **计算成本**:对于每一种组合,计算其成本,并考虑行和列交叉点的重复计算问题。 ### 复杂度分析 - **时间复杂度**:由于 `N` 和 `M` 的最大值为 8,因此枚举所有组合的时间复杂度为 $ O(N^{RowCount} \times M^{ColCount}) $,这在实际中是可接受的。 - **空间复杂度**:主要是存储预处理的成本,空间复杂度为 $ O(N + M) $。 ### 相关问题 1. 如何优化矩阵中行和列的枚举组合以减少计算时间? 2. 在计算行和列的交叉点时,如何更高效地处理重复计算的问题? 3. 如果矩阵的大小增加到更大的范围,如何调整算法以保持效率? 4. 如何处理矩阵中行和列的回文条件不同时的情况? 5. 如何扩展算法以支持更多的操作类型,例如翻转某个区域的值?
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值