牛客NC23046

牛客NC23046求A^B mod P

题目：

给定A,B,P；

输出T行；

输入：

2

2 5 10

57284938291657 827493857294857 384729583748273

输出：

2

18924650048745

备注：

1<=T<=10^3 ，
1<=A，B，P<=10^18

正常方法：

正常的我们会想到先求出a的b次方再对p取余
$$A^B\mathrm{mod}P$$
代码如下:

#include<stdio.h>
#include<math.h>
typedef long long int ll;
int main()
{
    ll T;
    ll A,B,P;
    ll i;
    scanf("%lld",&T);
    for(i=0;i<T;i++)
    {
        scanf("%lld%lld%lld",&A,&B,&P);
        A=pow(A,B);
        printf("%lld ",A%P);
    }
}

但是这样就会出现一个问题，当我们的a的b次方数字过大时，会导致数据溢出，而无法求出很大数据的a^b%p;

例如：57284938291657 827493857294857 384729583748273

这组A,B,P就会出现问题

预期输出应为：18924650048745

可实际输出为：0

快速幂取模方法：

于是我们就想用解决这个数据过大时该如何求出该数据的模

分为两步：

1.首先我们得知道先快速幂算法

2.再利用同模定理优化算法，从而完成快速幂取模算法

快速幂算法

从字面上来看意思就是很快的幂运算

实现原理：
$$\begin{gathered} 3^{10}=(3^2{)}^5=9^5=(9^2{)}^2\times 9 \\ =81^2\times 9=6561\times 9=59049 \end{gathered}$$
遇到偶次幂则令a=a×a(底数平方),b=b/2(指数除以2);

遇到奇次幂则令a=a×a(底数平方),b=b/2(指数除以2),再乘以未平方前的底数;

以上除法是采取计算机的除法形式,例如：1/2=0，2/2=1，3/2=1;

代码实现如下:

正常写法：

int my_pow(int a, int b)
{
	int ans = 1;
	while(b)
	{
		if (b % 2 == 1)
		{
			ans *= a;
		}
		a *= a;
		b /= 2;
	}
	
	return ans;
}

递归写法：

//int my_pow1(int a,int b,int ans1 = 1)
int my_pow1(int a, int b)
{
	static int ans1 = 1;
	if (b == 0)
	{
		int ans = ans1;
		ans1 = 1;
		return ans;
        //return ans1;
	}
	if (b % 2 == 1)
	{
		ans1 *= a;
	}
	return my_pow1(a*a,b/2);
    //return my_pow1(a*a,b/2,ans1);
}

static:在编程中，静态变量是指被声明在类或函数内部，但其生命周期与程序的执行周期相同。静态变量的值在程序运行过程中保持不变，可以在类的所有实例之间共享。

本人的理解：这里static使自己的生命周期增长到该进程结束，而并不是随着该函数的结束就死亡；

故若用递归的这个函数每回求出模以后要重新对ans1赋值令它重新赋值为1；

也可采用注释里的方法，将ans1 作为参数传递，并在递归调用时更新它的值，从而解决ans1更新问题;

进一步优化，快速幂取模算法

首先我们得了解同模定理

同模定理:
$$\begin{gathered} (A+B)\mathrm{mod}P=(A\mathrm{mod}P)+(B\mathrm{mod}P) \\ A\times B\mathrm{mod}P= \\ ((A\mathrm{mod}P)\times (B\mathrm{mod}P))\mathrm{mod}P \\ 推广一下: \\ A\times A=((A\mathrm{mod}P{)}^2)\mathrm{mod}P \\ {A}^B=((A\mathrm{mod}P{)}^B)\mathrm{mod}P \end{gathered}$$
根据同模定理:我写出了两个快速幂取模代码如下：

ull my_powmod(ull a, ull b, ull p)
{
	ull ans = 1;
	while (b>0)
	{
		if (b % 2 == 1)
		{
			ans = (ans * a) % p;
		}
		a = (a * a) % p;
		b /= 2;
	}
	return ans;
}

ull my_pow1mod(ull a, ull b, ull p,ull ans1=1)
{
	if (b == 0)
	{
		return ans1;
	}
	if (b % 2 == 1)
	{
		ans1 = (ans1 * a) % p;
	}
	return my_pow1mod((a * a) % p, b / 2, p,ans1);
}

但是该代码在测试用例时输出的值却与答案不符合

57284938291657 827493857294857 384729583748273

预期输出:18924650048745

实际输出:343442871792359

然后就发现即使使用unsinged long long，a*a还是溢出了

于是就想将A，B，P进行分治，

将乘法拆分为多次的加法操作，并在每一步加法操作后，将结果对给定的取模值进行取模操作，以确保结果的有效性。

代码如下:

ll mul(ll a, ll b, ll p) 
{
	ll res = 0;
	while (b) 
	{
		if (b % 2 == 1)
			res = (res + a) % p;
		b /= 2;
		a = (a + a) % p;
	}
	return res;
}
ll my_powmod(ll a, ll b, ll p)
{
	ll ans = 1;
	ll temp = a % p;
	while (b)
	{
		if (b % 2 == 1)
		{
			ans = mul(ans, temp, p);
		}
		temp = mul(temp, temp, p);
		b /= 2;
	}
	return ans;
}

如此，便可以求出57284938291657 的827493857294857次方对384729583748273取模的值啦！

最终代码如下:

#include<stdio.h>
typedef long long int ll;
//快速幂取模算法
ll mul(ll a, ll b, ll p) 
{
	ll res = 0;
	while (b) 
	{
		if (b % 2 == 1)
			res = (res + a) % p;
		b /= 2;
		a = (a + a) % p;
	}
	return res;
}
ll my_powmod(ll a, ll b, ll p)
{
	ll ans = 1;
	ll temp = a % p;
	while (b)
	{
		if (b % 2 == 1)
		{
			ans = mul(ans, temp, p);
		}
		temp = mul(temp, temp, p);
		b /= 2;
	}
	return ans;
}

int main() 
{
	ll T, A, B, P;
	scanf("%lld", &T);
	while(T)
	{
		scanf("%lld%lld%lld", &A, &B, &P);
		ll a = my_powmod(A, B, P);
		printf("%lld\n", a);
		T--;
	}
	return 0;
}
//测试用例
//2
//2 5 10
//57284938291657 827493857294857 384729583748273
//输出：
//2
//18924650048745

通过本题，我学习到了快速幂算法，同模定理与分治思想，最终AC该题，本人还在学习当中，其中肯定还有很多不足，如有发现，希望大家能指出，希望该篇文章对大家能有所帮助。


参考文章:https://www.cnblogs.com/kingwz/p/15257654.html

https://blog.csdn.net/chen_zan_yu_/article/details/90522763

题目来源:https://ac.nowcoder.com/acm/problem/23046