快速幂
快速幂:快速求a^b^ % p的问题,时间复杂度:O(logb),若对于n组数据,那么时间复杂度为O(n∗logb)
给定 𝑛 组 𝑎𝑖,𝑏𝑖,𝑝𝑖，对于每组数据，求出𝑎𝑖^𝑏𝑖^mod𝑝𝑖 的值。
输入格式
第一行包含整数 𝑛。
接下来 𝑛 行，每行包含三个整数 𝑎𝑖,𝑏𝑖,𝑝𝑖。
输出格式
对于每组数据，输出一个结果，表示 𝑎𝑖^𝑏𝑖^mod𝑝𝑖 的值。
每个结果占一行。
数据范围
1≤𝑛≤100000, 1≤𝑎𝑖,𝑏𝑖,𝑝𝑖≤2×10^9^
输入样例：
2
3 2 5
4 3 9
输出样例：
4
1
一.暴力解法 O(n∗b)会TLE
基本思路:对于n组数据,分别循环b次求出a^b^ mod p
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
while(n--)
{
int a,b,p;
long long res=1;
cin>>a>>b>>p;
while(b--)
res = res * a %p;
cout<<res<<endl;
}
}
二.快速幂解法 O(n∗logb)
基本思路:
注意:
- b&1就是判断b的二进制表示中第0位上的数是否为1,若为1,b&1=true,反之b&1=false
- b&1也可以用来判断奇数和偶数,b&1=true时为奇数,反之b&1=false时为偶数
快速幂之迭代版 O(n∗logb)
#include<iostream>
using namespace std;
long long qmi(long long a,int b,int p)
{
long long res=1;
while(b)//对b进行二进制化,从低位到高位
{
//如果b的二进制表示的第0位为1,则乘上当前的a
if(b&1) res = res *a %p;
//b右移一位
b>>=1;
//更新a,a依次为a^{2^0},a^{2^1},a^{2^2},....,a^{2^logb}
a=a*a%p;
}
return res;
}
int main()
{
int n;
cin>>n;
while(n--)
{
cin.tie(0);
ios::sync_with_stdio(false);
int a,b,p;
long long res=1;
cin>>a>>b>>p;
res = qmi(a,b,p);
cout<<res<<endl;
}
return 0;
}
快速幂之递归版 O(n∗logb)
#include<iostream>
using namespace std;
#define ull unsigned long long
ull quick_pow(ull a,ull b,ull p)
{
if(b==0) return 1;
a%=p;
ull res=quick_pow(a,b>>1,p);
if(b&1) return res*res%p*a%p;
return res*res%p;
}
int main()
{
int n;
cin>>n;
while(n--)
{
int a,b,p;
cin.tie(0);
ios::sync_with_stdio(false);
cin>>a>>b>>p;
cout<<quick_pow(a,b,p)<<endl;
}
return 0;
}
费马小定理 - 快速幂求逆元
给定 𝑛 组 𝑎𝑖,𝑝𝑖，其中 𝑝𝑖 是质数，求 𝑎𝑖 模 𝑝𝑖 的乘法逆元，若逆元不存在则输出 impossible。
注意：请返回在 0∼𝑝−1 之间的逆元。
乘法逆元的定义
若整数𝑏，𝑚 互质，并且对于任意的整数 𝑎，如果满足𝑏|𝑎，则存在一个整数 𝑥，使得 𝑎/𝑏≡𝑎×𝑥(mod𝑚)，则称 𝑥 为 𝑏 的模 𝑚 乘法逆元，记为 𝑏−1(mod𝑚)。
𝑏 存在乘法逆元的充要条件是 𝑏 与模数 𝑚 互质。当模数 𝑚 为质数时，bm−2𝑏𝑚−2 即为 𝑏 的乘法逆元。
输入格式
第一行包含整数 𝑛。
接下来 𝑛 行，每行包含一个数组 𝑎𝑖,𝑝𝑖，数据保证 𝑝𝑖 是质数。
输出格式
输出共 𝑛 行，每组数据输出一个结果，每个结果占一行。
若 𝑎𝑖 模 𝑝𝑖 的乘法逆元存在，则输出一个整数，表示逆元，否则输出 impossible。
数据范围
1≤𝑛≤10^5^, 1≤𝑎𝑖,𝑝𝑖≤2∗10^9^
输入样例：
3
4 3
8 5
6 3
输出样例：
1
2
impossible
import java.io.*;
class Main{
static BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
public static int qmi(int a, int k, int p){
long res = 1;
while(k > 0){
if((k & 1) != 0) res = res * a % p;
a = (int)((long) a * a % p);
k >>= 1;
}
return (int)res;
}
public static void main(String[] args) throws Exception{
int n = Integer.valueOf(read.readLine());
while(n -- > 0){
String[] ss= read.readLine().split(" ");
int a = Integer.valueOf(ss[0]);
int m = Integer.valueOf(ss[1]);
int qmi = qmi(a, m - 2, m);
if(a % m != 0) System.out.println(qmi);
else System.out.println("impossible");
}
}
}
当n为质数时，可以用快速幂求逆元： a / b ≡ a * x (mod n) 两边同乘b可得 a ≡ a * b * x (mod n) 即 1 ≡ b * x (mod n) 同 b * x ≡ 1 (mod n) 由费马小定理可知，当n为质数时 b ^ (n - 1) ≡ 1 (mod n) 拆一个b出来可得 b * b ^ (n - 2) ≡ 1 (mod n) 故当n为质数时，b的乘法逆元 x = b ^ (n - 2)
当n不是质数时，可以用扩展欧几里得算法求逆元： a有逆元的充要条件是a与p互质，所以gcd(a, p) = 1 假设a的逆元为x，那么有a * x ≡ 1 (mod p) 等价：ax + py = 1 exgcd(a, p, x, y)
快速幂求逆元
#include <iostream>
using namespace std;
typedef long long LL;
LL qmi(int a, int b, int p)
{
LL res = 1;
while(b){
if(b & 1) res = res * a % p;
a = (LL)a * a % p;
b >>= 1;
}
return res;
}
int main()
{
int n; cin >> n;
while(n --){
int a, p;
cin >> a >> p;
if(a % p == 0) puts("impossible");
else cout << qmi(a, p - 2, p) << endl;
}
return 0;
}
扩展欧几里得算法求逆元
#include <iostream>
using namespace std;
typedef long long LL;
int n;
int exgcd(int a, int b, int &x, int &y)
{
if (!b) {
x = 1, y = 0;
return a;
}
int d = exgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
int main()
{
cin >> n;
while (n --)
{
int a, p, x, y;
// if (a < p) swap(a, p);
cin >> a >> p;
int d = exgcd(a, p, x, y);
if (d == 1) cout << ((LL)x + p) % p << endl;//保证x是正数
else puts("impossible");
}
return 0;
}
