题解 P1630 【求和】

发现题解都不够优雅，就自己来一篇

( 以下除【代码】处代码，其余均为现场手打，如有误请与本蒟蒻联系 )

【分析】

首先，看清楚了，题目是 $\sum_{i=1}^ai^b$ 的余数，而不是 $\sum_{i=1}^ab^i$ ( 等比数列求和了解一下 )

毕竟......本蒟蒻一开始就看错了......

好，进入正题，介于 $a,b\leq 10^9$ ，暴力就想都不用想了，肯定过不了每一次乘法需要 $O(b)$ 的时间，加法需要 $O(a)$ 的时间，外部一个 $O(N)$ 的循环，总复杂度 $O(Nab)=10^{20}$ ，大概要 $10^{12} s$ ，也就是大概 $31710$ 年吧逃

首先，有一个很优秀的方法可以优化乘法，那就是 快速幂 ！

如果你要求 $a^x$ 那么你就先求出 $a^{\lfloor {x\over 2}\rfloor}$

然后 $a^{\lfloor {x\over 2}\rfloor}\times a^{\lfloor {x\over 2}\rfloor}$ 就完事啦！

递归边界在于当 $x=1$ 时 $a^1=a$

那奇数怎么办？我们知道 $a^4=a^2\times a^2$ ，但 $a^5\neq a^2\times a^2$ 啊

没事，你想， $a^5=a^2\times a^2\times a^1$ 对不对？

同理，$a^x=a^{\lfloor {x\over 2}\rfloor}\times a^{\lfloor {x\over 2}\rfloor}\times a$ ( $x$ 为奇数)

所以，我们可以递归地盘它了：

int pow(int a,int x){

	if(x==1) return a;

	int p=pow(a,x/2);

	if(x%2==1) return (p*p%Mod)*a%Mod;

	else return p*p%Mod;

}

当然，喜欢三目运算符和位运算的小伙伴们可以更优雅地盘它：

int pow(int a,int x){

	if(x==1) return a;

	int p=pow(a,x>>1);

	return (p*p%Mod)*((x&1)?a:1)%Mod;

}

这边再推荐一下非递归的打法，因为有的地方的评测机可能会爆栈：

int pow(int a,int x){

	int bas=a,ans=(x&1)?a:1;

	while(x>>=1){

		bas=bas*bas%Mod;

		if(x&1) ans=ans*bas%Mod;

	}

	return ans;

}

好的，我们可喜的发现，由于每次递归都是对半，求 $i^b$ 的方法优化到了 $O(\log b)$，现在的总复杂度为 $O(Na\log b)$ 了，大概为 $10^{12}$ 大概要 $10^4s$ 了，也就是 $3$ 小时再逃

这说明我们还是不够优雅的，我们还得继续优化

我们还能发现，根据同余的性质： $(a+10000)\equiv a (\mod 10000)$

两边同时翻 $b$ 次方得：

$(a+10000)^b\equiv a^b(\mod10000)$

这说明了啥？说明我们对于任何大于 $10000$ 的数 $n$ ，它的 $b$ 次方我们已经求过了，就是 $(n\%10000)^b$

因为本人是 C++ 选手，所以习惯用 $a\%b$ 表示 $a$ 除以 $b$ 的余数

好的，所以我们把 $1$ ~ $10000$ 的 $b$ 次方存起来，比如用 $c_i$ 表示 $i^b\%10000$ 。

我们先预处理 $c_1$~$c_{10000}$ ，接下来，每次我们要 $i^b$ ，就直接用 $c_{i\%10000}$ 即可。

耶！总复杂度又下降了，每次预处理都是 $O(10000\log b)$ 的，统计是 $O(a)$ 的

$\because 10000\log b\leq 10^4\times 10^2=10^6\leq 10^9=a$

$\therefore O(10000\log b)+O(a)=O(a)$

总复杂度为 $O(Na)=10^{11}$ , 大概 $20$ 分钟吧继续逃

至此，我们还能发现，对于给定的 $a$ ，我们需要将 $c_1$~$c_{10000}$ 的加和计算 $\lfloor{a\over 10000}\rfloor$ 次，剩下的就是从 $(\lfloor{a\over 10000}\rfloor\times 10000+1)$ 到 $a$ 的再各多记一次

也就是把加和乘上 $\lfloor{a\over 10000}\rfloor$ ,再加上 $c_1$~$c_{a\%10000}$ 的和就可以了

有的机智的小朋友立即意识到了，可以把 $c_1$~$c_{10000}$ 的和记录起来，接下来的一个循环搞掉，岂不美哉

但是为什么要那么复杂呢？

我们令 $Add_n=\sum_{i=1}^nc_i$

那么，我们的答案就应该是 $Add_{10000}\times \lfloor{a\over 10000}\rfloor+Add_{a\%10000}$

这个实际上叫做前缀和

不是吗？

所以现在很明确了吧，我们要的是 $Add_n$ ，只要这个一出来，我们就可以根据公式，$O(1)$ 输出答案了

那 $Add_n$ 又怎么求？ $c_n$ 全部算出来然后每次算 $Add_n$ 都一遍扫过去？

复杂度 $O(n^2)$ 的事情过于暴力了吧

我们想：

$Add_n=\sum_{i=1}^nc_i=\sum_{i=1}^{n-1}c_i+c_n=Add_{n-1}+c_n$

所以我们只要一遍算 $c_n$ 的时候统计 $Add_n$ 即可

这次，预处理复杂度 $O(10000\log b)$ ,输出答案是 $O(1)$ 的，总复杂度 $O(10000N\log b)=10^7$ 可以做到一秒出结果了

【进阶】

这边讲一个毫无意义的进阶，虽然对复杂度和答案毫无影响，但确实看起来更优雅：

由欧拉定理得： $a^{\varphi(n)}\equiv1(\mod n)$

对于右上角那个鬼东西，它叫欧拉函数，是指小于 $n$ 的正整数中，与其互质的数的个数

也有的版本是说小于等于 $n$ 的正整数中，与其互质的数的个数

关于欧拉函数的性质，你们可以看看我这篇文章中讲欧拉函数的那一部分，其它的可以跳过

至于欧拉定理，记住它就行 OI是不需要数学证明的

根据公式 $\varphi(10000)=4000$ 所以，我们不需要算 $b$ 次方的快速幂，$b\%4000$ 的快速幂即可

这样，您的代码将看起来更加的优雅、大气

hrq：“我现在终于知道了，代码优雅指的就是别人看不懂！原来我代码不优雅是褒义词！”

(P.S. 虽然丝毫不影响复杂度)

【代码】

好的，废话了那么多，本蒟蒻要放我码风极丑无比的代码了

代码前面加了一些读入和输出优化，无视即可

#include<cstdio>

#include<cstring>

using namespace std;

#define f(a,b,c,d) for(register int a=b,c=d;a<=c;a++)

#define g(a,b,c,d) for(register int a=b,c=d;a>=c;a--)

#define File(s) freopen(s".in","r",stdin);freopen(s".out","w",stdout);

typedef int i32;

typedef long long int i64;

const int Mod=10000;

namespace INPUT{

	char s[1<<20|1],*p1=s,*p2=s;

	inline char gc() { return (p1==p2)&&(p2=(p1=s)+fread(s,1,1<<20|1,stdin),p1==p2)?EOF:*(p1++); }

	inline i32 read(){

		register i32 ans=0;register char c=gc();register bool neg=0;

		while(c<48||c>57) neg^=!(c^'-'),c=gc();

		while(c>=48&&c<=57) ans=(ans<<3)+(ans<<1)+(c^48),c=gc();

		return neg?-ans:ans;

	}

}

namespace OUTPUT{

	char s[1<<20|1],*cur=s;

	inline void output(){ cur-=fwrite(s,1,cur-s,stdout); }

	inline void print(i32 x){

		char tmp[16],*p1=tmp,*p2=tmp;

		p2+=sprintf(tmp,"%d",x);

		if(cur-s+p2-p1>>20) output();

		while(p1<=p2) *(cur++)=*(p1++);

		cur--;

	}

	inline void print(char c){

		if(cur-s+1>>20) output();

		*(cur++)=c;

	}

}

using namespace INPUT;

using namespace OUTPUT;

//前面全是读入输出优化，无视它们

inline i32 pow(i32 d_A,i32 d_X){

	i32 d_Bas=d_A,d_Ans=(d_X&1)?d_A:1;

	while(d_X>>=1){

		d_Bas*=d_Bas;

		d_Bas%=10000;

		if(d_X&1) d_Ans*=d_Bas,d_Ans%=10000;

	}

	return d_Ans;

}//快速幂

inline i32 work(i32 d_A,i32 d_B){

	i32 ar_d_Add[Mod+1]={0};

	f(i,1,I,Mod) ar_d_Add[i]=ar_d_Add[i-1]+pow(i,d_B),ar_d_Add[i]-=( (ar_d_Add[i]>=Mod)?Mod:0 );

	i32 d_Ans= d_A/Mod%Mod * ar_d_Add[Mod]%Mod + ar_d_Add[d_A%Mod];

	return d_Ans>=Mod?(d_Ans-Mod):d_Ans;

}//计算结果

i32 main(){

	i32 d_N=read();

	while(d_N--){

		int d_A=read(),d_B=read()%4000;

		print( work(d_A,d_B) );

		print('\n');

	}

	output();

	return 0;

}//对于主函数尽可能剪短的特殊癖好

最后安利一下本蒟蒻的博客