HDU 1452 Happy 2004 因子和函数 积性函数 逆元*

由唯一分解定理一个数N可分解成质因数的乘积
N=a1^k1a2^k2……an^kn其中 a1,a2,a3……都为质数
则N的因数的和S为(a1⁰+a1¹+……a1^k1)(a2⁰+a2¹+……a2^k2)……(an⁰+an¹+……an^kn)
因为N的因子都是质因数的组合,a1的次数可取0到k1,a2的次数可取0到k2……a1到an的次数的每种组合都对应了一个因数，把这些相加就得到了因数的和
因数的个数F为(1+k1)(1+k2)……（1+kn）同样的a1可取0到k1,a2可取0到k2
此外还可以用等比数列公式对S进行化简，S=(a1^k1+1-1)/(a1-1)*(a2^k2+1-1)/(a2-1)……（an^kn+1-1）/(an-1)，
特别的当N=p^x其中p为质数
则S=(p^x+1-1)/(p-1)

又S是个积性函数，即当gcd(a,b)=1时，有S(ab)=S(a)S(b),
所以S(N)=S(a1^k1)S(a2^k2)……S(an^kn)
由以上S(p^x)的公式，则就要计算ai^ki+1要用到快速幂，同时还除了一个ai-1要用到ai-1关于mod的逆元

这题中2004^x=2^2x*3^x*167^x 需要计算2,3,167的快速幂，同时还要计算3-1=2关于29的逆元，166关于29的逆元，可用费马小定理快速得出（但是有点大）
也可以凑出来。

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
#define ll long long
#define MOD 29
ll quickpow(ll base, ll pow)
{
	ll ans = 1;
	while (pow)
	{
		if (pow & 1)
			ans = (base * ans) % MOD;
		pow >>= 1;
		base = (base * base) % MOD;
	}
	return ans%MOD;
}
int n;
int main()
{
	while (scanf("%d", &n) != EOF && n != 0)
	{
		ll t1 = (quickpow(2, 2 * n + 1) - 1) % MOD;
		ll t2 = (((quickpow(3, n + 1) - 1) % MOD) * 15) % MOD;
		ll t3 = ((quickpow(167, n+1) - 1) % MOD * quickpow(166, 27) % MOD) % MOD;
		ll t = (t1 * t2 * t3) % MOD;
		printf("%lld\n", t);
	}
	return 0;
}

这样的时间复杂度为lgn级别，只要计算几个快速幂就可以了，而且不用计算2004^x 也不会爆ll什么的
而传统的计算一个数n的所有因子和，从1到根号n遍历，时间复杂度为根号n,更不用谈计算2004^x的过程
如果我们不知道一个数能够分解成什么质因数，那就还要考虑分解质因数的过程

int main()
{
	while (scanf("%d", &n) != EOF)
	{
		int k=0;
		for (int i = 2; i * i <= n; i++)
		{
			if (n % i == 0)
			{
				di[k] = i;
				while (n % i == 0)
				{
					po[k]++;
					n = n / i;
				}
				k++;
			}
		}
		if (n > 1)
		{
			di[k] = n;
			po[k++ ]++;
		}
		printf("次数:\n");
		for (int i = 0; i < k; i++)
		{
			printf("%d ", po[i]);
		}
		printf("\n");
		printf("质因数:\n");
		for (int i = 0; i < k; i++)
		{
			printf("%d ", di[i]);
		}
		printf("\n");

	}
	return 0;
}