发现题解都不够优雅，就自己来一篇
( 以下除【代码】处代码，其余均为现场手打，如有误请与本蒟蒻联系 )
【分析】
首先，看清楚了，题目是 \(\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;
}//对于主函数尽可能剪短的特殊癖好
最后安利一下 本蒟蒻的博客