Number Theory in Competitive Programming

Gyumin Roh
August 17, 2016

1 GCD, LCM, Euclidean Algorithm

The definitions of GCD and LCM are well-known, (and taught in middle school I think)
I will skip the definitions.
Also, since lcm(a, b) · gcd(a, b) = ab, calculating GCD is equivalent to calculating LCM.
Now, how do we calculate the GCD of two numbers?
A naive solution would be iterating over all positive integers no more than min(a, b).
This will get the GCD in O(min(a, b)), very very slow.
We can calculate the GCD of a, b in O(log ab) using Euclidean Algorithm. This algorithm
uses the easy-to-prove fact gcd(a, b) = gcd(b, r), where r is the remainder when a is
divided by b, or just a%b.
We can now use the following code.
#include <iostream>
using namespace std;
int gcd(int u, int v)
{
return u%v==0?v:gcd(v,u%v);
}
int main(void)
{
int x, y;
cin>>x>>y;
cout<<gcd(x,y);
}

How do we prove that this algorithm is O(log ab)? Well, let’s suppose that we started
with (a, b). Then, we go to (b, r), where r is defined similarly as above. It can be proved
1
that br < ab. Therefore, the product of two numbers in the function decreases by half
2
every time. Done!
Here’s a challenge. Can we find the numbers x, y such that ux + vy = gcd(u, v)?
There exists infinitely many pairs - this is Bezout’s Lemma. The algorithm to generate
such pairs is called Extended Euclidean Algorithm.

2 Generating Primes, Prime Test, Prime Factorization

Generating primes fast is very important in some problems. Let’s cut to the chase and
introduce Eratosthenes’s Sieve.
The main idea is the following. Suppose we want to find all primes between 2 and 50.
Iterate from 2 to 50. We start with 2. Since it is not checked, it is a prime number.
Now check all numbers that are multiple of 2 except 2. Now we move on, to number 3.

1
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

It’s not checked, so it is a prime number. Now check all numbers that are multiple of 3,
except 3. Now move on to 4. We see that this is checked - this is a multiple of 2! So 4 is
not a prime. We continue doing this.
Here’s the implementation.
#include <stdio.h>
int primechk[21000];

void preprocess(void)
{
int i, j;
for(i=2 ; i<=20000 ; i++)
{
primechk[i]=1;
}
for(i=2 ; i<=20000 ; i++)
{
if(primechk[i]==1)
{
for(j=2 ; i*j<=20000 ; j++)
{
primechk[i*j]=0;
}
}
}
}

int main(void)
{
preprocess();
int i, cnt=0;
for(i=2 ; i<=20000 ; i++)
{
if(primechk[i]==1)
{
cnt++;
printf("%d is the %dth prime!\n",i,cnt);
}
}
}

Okay, so what is the time complexity? To get all primes in the interval [1, n], the TC of
this algorithm is O(n log log n). Very X
very fast. To prove this, notice that the number of
n
iterations are something like O(n) + where p is a prime.
p
p≤n
X1
Well, Merten’s Second Theorem states that = log log n + O(1) (natural logarithm,
p
p≤n
by the way) so this prove the TC.
Now we know how to generate prime numbers fast. How about primality testing?
√
Naive solutions first. Given an integer n, we can check numbers up to n to find if a
number divides n. If there is such a number, n is composite. If not, n is a prime. This
√
gives the solution in O( n).
Here’s a "solution" in O(c ln n) using the fast exponentiation we will talk about in
the next section. It’s called Miller-Rabin Primality Test. I’ll introduce the deterministic

2
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

version. We probably (hopefully) won’t see stuff like n > 4 · 109 in contests.
Here’s the sketch of the algorithm. Choose some set of a. We will run the algorithm
with different as, and the more as we run this algorithm with, the more accurate this
primality test is going to be.
Decompose n − 1 as 2s · d. Then check if the following holds.
rd
ad 6≡ 1 (mod n) and a2 6≡ −1 (mod n) for all r ∈ [0, s − 1]

If there is an a that satisfies this, n is composite. If not, n is a prime.

For n < 4.7 · 109 , we can just check for a = 2, 7, 61 and be sure about it. For n < 264 ,
we can check for a = 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 and be confident.
Now let us look at prime factorization of numbers.
Assume that we generated prime numbers using the Eratosthenes’s Sieve. If n is in
the "prime-generated" range, we can actually do prime factorization in O(log n). Make
another array. While we are doing the Sieve, for composite numbers, put "the first prime
that verified that this number is composite" and for prime numbers, put itself. This is
easy to implement.
Then we can start with n, and continue to divide the prime numbers in the array.
#include <stdio.h>
int primechk[21000];
int fprime[21000];
void preprocess(void)
{
int i, j;
for(i=2 ; i<=20000 ; i++)
{
primechk[i]=1;
}
for(i=2 ; i<=20000 ; i++)
{
if(primechk[i]==1)
{
fprime[i]=i;
for(j=2 ; i*j<=20000 ; j++)
{
primechk[i*j]=0;
if(fprime[i*j]==0)
{
fprime[i*j]=i;
}
}
}
}
}

int main(void)
{
preprocess();
int n;
scanf("%d",&n);
while(n!=1)
{
printf("%d\n",fprime[n]);
n=n/fprime[n];
}

3
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

}
√
If not, we can just check through all primes less than n and divide by those primes
until we can’t. If all the primes multiply up to n, we are done. If not, there is exactly one
√
prime more than n that divides n.
Another algorithm involving prime factorization is Pollard’s rho algorithm - since the
pseudocode is simple, I’ll leave you the wikipedia link: Pollard’s rho algorithm

3 Playing with Modulars, and Euler Phi Function

Quick stuff first, fast exponentiation in logarithm time.
Let us calculate ab in modular m in O(log b). It uses binary expansion of b, and is very
very straightforward.
ll exp(ll x, ll n)
{
if(n==0) return 1;
if(n==1) return x;
if(n%2==0) return exp((x*x)%mod,n/2);
if(n%2==1) return (x*exp((x*x)%mod,n/2))%mod;
}

Now, let us talk about modular inverses.

By using Extended Euclidean Algorithm, we can get the inverse of a modulo m.
#include <iostream>
int inv(int a, int m)
{
int temp=m, q, t, u=0, v=1;
if(m==1) return 0;
while(a>1)
{
q=a/m;
t=m;
m=a%m;
a=t;
t=u;
u=v-q*u;
v=t;
}
if(v<0) v+=temp;
return v;
}
int main(void)
{
int a, m;
std::cin>>a>>m;
std::cout<<inv(a,m);
}

Of course, logarithm time. If m is prime, we can do a lot of different things.

Fermat’s Little Theorem gives ap−1 ≡ 1 (mod p) if (a, p) = 1, where p is a prime.
Therefore, we can calculate the modular inverse of a as ap−2 , by fast exponentiation.
Time Complexity is O(log p).

4
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

Also, you can get the modular inverse of all numbers in [1, n] in O(n). The code for
this is shown below. The proof for the correctness is left to the reader (not difficult)
#include <iostream>
typedef long long ll;
using namespace std;
int inv[111111], n;
ll mod=1e9+7;
int main(void)
{
cin>>n;
int i;
inv[1]=1;
for(i=2 ; i<=n ; i++)
{
inv[i]=((mod-mod/i)*inv[mod%i])%mod;
cout<<inv[i]<<endl;
}
}
 
n
We can also calculate in modulo p (p is a prime) very fast using Lucas’ Theorem.
m      n 
n n0 bpc
Lucas’ Theorem basically states that ≡ · m , where n0 is n modulo p
m m0 bpc
and m0 is m modulo p.
This is very efficient when p is small and n, m is huge. We can precalculate the factorials
and inverse of factorials modulo p by using the above code, and solve each queries in
O(logp max(n, m)).
Also, we can use Chinese Remainder Theorem to solve a system of modular equations.
Let us solve x ≡ ri (mod mi ), where mi are pairwise coprime. (If they are not coprime,
break them into prime powers, and if some are contradictory, there are no solutions.)
n
Y M
The CRT itself gives an algorithm to get our answer. Set M = mi , and ui = .
mi
i=1
X n
Also, set si as the modular inverse of ui in modulo mi . Then our answer is ri si ui
i=1
(mod M ).
We learned how to calculate modular inverse in logarithm time above. So the time
complexity is O(n log M AX).
long long int r[111111]; // remainders
long long int m[111111]; // modulars
long long int M=1; // product
int n; // number of equation
int res(void)
{
int i;
for(i=1 ; i<=n ; i++)
{
M=M*m[i];
}
long long int ret=0;
for(i=1 ; i<=n ; i++)
{

5
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

ret+=r[i]*inv(M/m[i],m[i])*(M/m[i]);
ret=ret%M;
}
return ret;
}

φ(n) is the number ofpositive integers no more than n which is coprime with n. Formula is
Y 1 X
φ(n) = n 1− . Proof is Inclusion-Exclusion. Also, we have the formula φ(d) =
p
p|n d|n
n.
Of course, for the calculation of Euler Phi numbers, we can tweak the Eratosthenes’s
Sieve algorithm a little bit.
void preprocess(void)
{
int i, j;
eulerphi[1]=1;
for(i=2 ; i<=122000 ; i++)
{
eulerphi[i]=i;
primechk[i]=1;
}
for(i=2 ; i<=122000 ; i++)
{
if(primechk[i]==1)
{
eulerphi[i]-=eulerphi[i]/i;
for(j=2 ; i*j<=122000 ; j++)
{
primechk[i*j]=0;
eulerphi[i*j]-=eulerphi[i*j]/i;
}
}
}
}

You could also calculate φ(n) by using prime factorization of n.

Now let’s get to the fun stuff. The Mobius function.

4 Mobius Function Part 1. The Introduction

What is mobius function? This function is notated as µ(n). This function has lots of
definitions. However, the main definition is the following.

• µ(n) is 1 if n = 1 or n is square-free and has even number of prime divisors.

• µ(n) is −1 if n is square-free and has odd number of prime divisors.

• µ(n) is 0 if n is not square-free.

µ(n)
Xalso has a lot of interesting properties that make µ(n) so important.
µ(d) = 0 for all n > 1, and µ(n) is multiplicative. (A function f is multiplicative if
d|n
f (mn) = f (m)f (n) for all (m, n) = 1.)

6
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

How do we calculate µ(n) fast? Again, we can tweak the Eratosthenes’s Sieve a little
bit.
void preprocess(void)
{
int i, j;
for(i=1 ; i<=111100 ; i++)
{
mu[i]=1;
primechk[i]=1;
}
primechk[1]=0;
for(i=2 ; i<=111100 ; i++)
{
if(primechk[i]==1)
{
mu[i]=-mu[i];
for(j=2 ; i*j<=111100 ; j++)
{
primechk[i*j]=0;
if(j%i==0)
{
mu[i*j]=0;
}
else
{
mu[i*j]=-mu[i*j];
}
}
}
}
}

Okay, O(n log log n) is good. Now, how do we use µ(n)?

5 Mobius Function Part 2. Mobius Inversion, Dirichlet

Convolution.
X
Theorem 1. Let f (n), g(n) be arithmetic function such that g(n) = f (d). Then,
d|n
X n
f (n) = µ(d)g .
d
d|n

7
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

Chứng minh.
X n X X
µ(d)g = µ(d) f (c)
d
d|n d|n c| n
d
XX
= µ(d)f (c)
d|n c| n
d
XX
= f (c)µ(d)
c|n d| nc
X X
= f (c) µ(d) = f (n)
c|n d| nc

X
using µ(d) = 0 for all n > 1 and µ(1) = 1.
d|n

The Dirichlet Convolution of two function f, g is the following.

X
(f ∗ g)(n) = f (u)g(v)
uv=n

Denote 1 as the constant function, f (n) = 1. (n) is a function which satisfies (1) = 1
and (n) = 0 for n 6= 1. Id(n) is the identity function, Id(n) = n
The mobius inversion formula and the basic property of mobius functions give 1 ∗ µ = ,
and g = f ∗ 1 ⇐⇒ f = g ∗ µ
Okay. So what? How can we use this formula to solve problems?
We can, change our "sum" or our answer using mobius inversion and mobius functions
to calculate them fast.
I will give 3 examples which changes the desired sum by using number theory (like
mobius function) to calculate them fast.

Example 2. SPOJ LCM Sum

Solution.
n n X nφ( n )
X X i d n nX
lcm(i, n) = n =n+n = + dφ(d)
gcd(i, n) 2d 2 2
i=1 i=1 d|n,d6=n d|n

Let res[x] be the answer when n = x.

Precalculate φ(d), and add dφ(d) to every res[i · d].
x
Then multiply to res[x] + 1.
2
This gives our solution in O(n log n + T ). yay
#include <stdio.h>
#include <iostream>
using namespace std;
typedef long long int ll;
ll res[1000010];
ll phi[1000010];
void preprocess(void)
{
for(int i=1 ; i<=1000000 ; i++)
{
phi[i]=i;

8
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

}
for(int i=2 ; i<=1000000 ; i++)
{
if(phi[i]==i)
{
for(int j=1; i*j<=n; j++)
{
phi[i*j]-=phi[i*j]/i;
}
}
}
for(int i=1 ; i<=1000000 ; i++)
{
for(int j=1; i*j<=1000000 ; j++)
{
res[i*j]+=i*phi[i];
}
}
}

int main(void)
{
preprocess();
int tc;
cin>>tc;
while (tc--)
{
ll n;
scanf("%lld",&n);
ll ans=res[n]+1;
ans=(ans*n)/2;
printf("%lld\n",ans);
}
return 0;
}

Example 3. Codechef Coprime Triples

n X
X n n
X
Solution. Here’s the key sum transformation. We want (gcd(ai , aj , ak )).
i=1 j=i+1 k=j+1
Using 1 ∗ µ = , we can transform P this sum. I’ll explain this step-by-step.
Start with (gcd(ai , aj , ak )) as d|gcd(ai ,aj ,ak ) µ(d). Now let’s decide how many µ(d)
appears in this sum. Clearly, it is the number of 3-tuples (i, j, k) such that d|a  i ,d|aj , d|ak .
k
Therefore, if k is the number of ai s which is a multiple of d, µ(d) appears times.
3
M AX  
X divcnt[k]
Therefore, our result is µ(k) · , where divcnt[k] is the number of ai s
3
k=1
which are a multiple of k.
We can precalculate binomial numbers, µ(k)s, and divcnt[k] easily in O(M AX log M AX),
where M AX is the maximum of ai s.
#include <stdio.h>
#include <algorithm>

9
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

#include <vector>
#include <string.h>
#include <string>
#include <stack>
#include <queue>
#include <iostream>
#include <assert.h>
#include <math.h>
using namespace std;
typedef long long int ll;
ll primechk[111111];
ll mu[111111];
ll divcnt[111111];
ll cnt[111111];
ll com[333][333];
ll ans, mod=1e7+3;
int n;

void input(void)
{
int i, j, x;
cin>>n;
for(i=1 ; i<=n ; i++)
{
scanf("%d",&x);
cnt[x]++;
}
}

void divpproc(void)
{
int i, j, x;
for(i=1 ; i<=110000 ; i++)
{
for(j=1 ; i*j<=110000 ; j++)
{
divcnt[i]+=cnt[i*j];
}
}
}

void compproc(void)
{
com[0][0]=1;
int i, j;
for(i=1 ; i<=320 ; i++)
{
com[i][0]=1;
com[i][i]=1;
}
for(i=2 ; i<=320 ; i++)
{
for(j=1 ; j<=i-1 ; j++)
{
com[i][j]=(com[i-1][j-1]+com[i-1][j]);
}
}

10
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming

void preprocess(void)
{
int i, j;
for(i=1 ; i<=111100 ; i++)
{
mu[i]=1;
primechk[i]=1;
}
primechk[1]=0;
for(i=2 ; i<=111100 ; i++)
{
if(primechk[i]==1)
{
mu[i]=-mu[i];
for(j=2 ; i*j<=111100 ; j++)
{
primechk[i*j]=0;
if(j%i==0)
{
mu[i*j]=0;
}
else
{
mu[i*j]=-mu[i*j];
}
}
}
}
}

void calc(void)
{
int i, j;
for(i=1 ; i<=105000 ; i++)
{
ans=ans+mu[i]*com[divcnt[i]][3];
}
}

int main(void)
{
preprocess();
input();
divpproc();
compproc();
calc();
cout<<ans;
}

Example 4. Codechef Expected Greatest Common Divisor

Sketch. Here’s a sketch. Calculating denominator + calculating inverse of it is just

modular inverse calculation.

11
Gyumin Roh (August 17, 2016) Number Theory in Competitive Programming
X
The main problem is calculating the sum of all gcds. Using φ(d) = n, we can change
d|n
the sum. X
The sum is pretty much g · number of tuples that have gcd g.
g
X
Now change g to φ(d). Therefore, we can change the sum to
d|g

X
φ(d) · number of tuples that have gcd a multiple d.
d

But this is way easier to calculate! For the gcd to be a multiple of d, we can just use
k−1
Y
number of multiple of d in the interval [Ai , Bi ]. Done!
i=0

In the more harder problems, the result of mobius inversion gets more complex, and
j nin
k
some problems we also have to keep track of some prefix sums and use the fact that
√ i
takes O( n) values. But that is for later.
Thanks for reading this. Hope this helped.

12