**Issues into**

Is well known, there is a magical thing called "combination number", abbreviated C, often appears in a variety of topics in number

is also well known, the number of combinations is the formula

C (n, m) = n ! / ((Nm)! * M !)

However, since this number can be large, even the legendary __int128 are kept high, so we often need a modulus

so formulas combination becomes

C (n, m) = n ! / ((nm) ! * m!)% p

At this time, the problem came, we all know that (a / b)% p! = a% p / b% p, this time, we need to use the multiplicative inverse

**Inverse defined**

We require that if a * x mod p = 1, and gcd (a, b) = 1 we define: x is the inverse of a, denoted a ^{-1}

we can say x is a reciprocal sense in mod b

**Inverse element method**

There are many ways the inverse element, such as Euclid, fast power, as well as linear recurrence method of expansion, first introduced here fast power algorithm and linear algorithm

**Fast Power Algorithm**

It should be a reference to Theorem: Fermat's little theorem (or Euler's theorem)

Let us talk about Fermat's little theorem

when it is time to prime numbers p, A ^{p-1} MOD p = 1

Euler's theorem is a ^ phi (p) mod p 1 =

Phi (I) n represents from 1 to n and the number of prime numbers

, however, when we found that when p is prime number, phi (p) = p- 1, so Fermat's little theorem is Euler's theorem part of

that is, when it is time to prime numbers p, a ^{-1} MOD p = a ^{p-2} MOD p

using fast power to solve it

here by default we will quickly power up

Example: In seeking a inverse mod p meaning

the code:

```
inline int read(){
int s=0,w=1;
char c=gc;
while(c<'0'||c>'9'){if(c=='-')w=-1;c=gc;}
while(c>='0'&&c<='9')s=s*10+c-'0',c=gc;
return s*w;
}
int n,p;
inline int Qpow(int base,int ind){
int ans=1;
while(ind){
if(ind&1)ans=1ll*ans*base%p;
base=1ll*base*base%p;
ind>>=1;
}
return ans;
}
int main()
{
n=read(),p=read();
printf("%d\n",Qpow(n,p-2));
return 0;
}
```

~~It seems like most of them are quick power~~

of this method can be linked to the number of combinations, as we introduce the same problem, there will be explained later, there is no more first repeat

**Linear algorithm**

Linear Recursive be used to calculate the inverse number of consecutive string

Here there are just examples, direct reference

Luo Gu P3811 [template] multiplicative inverse

This is a linear recurrence of the problem, in fact, I think he is not good out of this question, because I really have not seen a few channels with linear recursion problem doing

~~it may be I was too dishes~~

This question is the use of fast power of o (nlogn) should not pass the

so we can use this method

first of all we have this formula. 1 ^{-1} MOD P =. 1

and provided p = k * i + r ( 0 <r <i <p) that is, k is the quotient p / i, r is the remainder

Then this formula into mod p significance under'll get:

（k*i+r）mod p = 0

Is then multiplied by I ^{-1} R & lt ^{-1}

k * r^{-1} + i^{-1} mod p = 0

I ^{-1} and * R & lt -k ^{-1} for p congruence

in ^{-1}和- (p / i) * (p v i) ^{-1} mod p

The core code is very short

```
inv[1]=1;
printf("1\n");
Rep(i,2,n)inv[i]=(ll)(p-p/i)*inv[p%i]%p,printf("%d\n",inv[i]);
```

~~Pressure line Dafa Is Good~~

**to sum up**

Multiplicative inverse number theory is a very important piece, many provinces the number of topics selected to be used in multiplicative inverse

We must take control