You are given two numbers $n$ and $k$. Find the largest power of $k$ $x$ such that $n!$ is divisible by $k^x$.

Binomial coefficients have many different properties. Here are the simplest of them:

* Symmetry rule:

* Factoring in:

* Sum over $k$:

* Sum over $n$:

* Sum over $n$ and $k$:

* Sum of the squares:

* Weighted sum:

* Connection with the [Fibonacci numbers](../algebra/fibonacci-numbers.md):

If the entire table of values is not necessary, storing only two last rows of it is sufficient (current $n$-th row and the previous $n-1$-th).

Finally, in some situations it is beneficial to precompute all the factorials in order to produce any necessary binomial coefficient with only two divisions later. This can be advantageous when using [long arithmetic](../algebra/big-integer.md), when the memory does not allow precomputation of the whole Pascal's triangle.

Quite often you come across the problem of computing binomial coefficients modulo some $m$.

The previously discussed approach of Pascal's triangle can be used to calculate all values of $\binom{n}{k} \bmod m$ for reasonably small $n$, since it requires time complexity $\mathcal{O}(n^2)$. This approach can handle any modulo, since only addition operations are used.

The formula for the binomial coefficients is

so if we want to compute it modulo some prime $m > n$ we get

First we precompute all factorials modulo $m$ up to $\text{MAXN}!$ in $O(\text{MAXN})$ time.

Let $c(x)$ be that number.

And let $g(x) := \frac{x!}{p^{c(x)}}$.

Then we can write the binomial coefficient as:

The interesting thing is, that $g(x)$ is now free from the prime divisor $p$.

This gives us $h$ different congruences.

Since all moduli $p_i^{e_i}$ are coprime, we can apply the [Chinese Remainder Theorem](../algebra/chinese-remainder-theorem.md) to compute the binomial coefficient modulo the product of the moduli, which is the desired binomial coefficient modulo $m$.

When $n$ is too large, the $\mathcal{O}(n)$ algorithms discussed above become impractical. However, if the modulo $m$ is small there are still ways to calculate $\binom{n}{k} \bmod m$.

The number of balanced bracket sequences with only one bracket type can be calculated using the [Catalan numbers](catalan-numbers.md).

The number of balanced bracket sequences of length $2n$ ($n$ pairs of brackets) is:

If we allow $k$ types of brackets, then each pair be of any of the $k$ types (independently of the others), thus the number of balanced bracket sequences is:

It is clear that inside this pair there is a balanced bracket sequence, and similarly after this pair there is a balanced bracket sequence.

So to compute $d[n]$, we will look at how many balanced sequences of $i$ pairs of brackets are inside this first bracket pair, and how many balanced sequences with $n-1-i$ pairs are after this pair.

Consequently the formula has the form:

The initial value for this recurrence is $d[0] = 1$.

If we find do suitable position, then this sequence is already the maximal possible one, and there is no answer.

bool next_balanced_sequence(string & s) {

int n = s.size();

int depth = 0;

Here is an implementation using two types of brackets: round and square:

string kth_balanced2(int n, int k) {

vector<vector<int>> d(2*n+1, vector<int>(n+1, 0));

d[0][0] = 1;

For example, suppose $n = 3$, and the tree consists of the root $1$ and its two children $2$ and $3$.

Then the following functions $f_1$ and $f_2$ are considered equivalent.

Intuitively this is understandable - we can rearrange the children of vertex $1$, the vertices $2$ and $3$, and after such a transformation of the function $f_1$ it will coincide with $f_2$.

But formally this means that there exists an **invariant permutation** $\pi$ (i.e. a permutation which does not change the object itself, but only its representation), such that:

So starting from the definition of objects, we can find all the invariant permutations, i.e. all permutations which do not change the object when applying the permutation to the representation.

Then **Burnside's lemma** goes as follows:

the number of equivalence classes is equal to the sum of the numbers of fixed points with respect to all permutations from the group $G$, divided by the size of this group:

Although Burnside's lemma itself is not so convenient to use in practice (it is unclear how to quickly look for the value $I(\pi)$, it most clearly reveals the mathematical essence on which the idea of calculating equivalence classes is based.

The proof was published by Kenneth P. Bogart in 1991.

We need to prove the following statement:

The value on the right side is nothing more than the number of "invariant pairs" $(f, \pi)$, i.e. pairs such that $f \pi \equiv f$.

It is obvious that we can change the order of summation.

We let the sum iterate over all elements $f$ and sum over the values $J(f)$ - the number of permutations for which $f$ is a fixed point.

To prove this formula we will compose a table with columns labeled with all functions $f_i$ and rows labeled with all permutations $\pi_j$.

Therefore within each column of a given equivalence class any element $g$ occurs exactly $J(g)$ times.

Thus if we arbitrarily take one column from each equivalence class, and sum the number of elements in them, we obtain on one hand $|\text{Classes}| \cdot |G|$ (simply by multiplying the number of columns by the number of rows), and on the other hand the sum of the quantities $J(f)$ for all $f$ (this follows from all the previous arguments):

We denote by $C(\pi)$ the number of cycles in the permutation $\pi$.

Then the following formula (a **special case of the Pólya enumeration theorem**) holds:

$k$ is the number of values that each representation element can take, in the case of the coloring of a binary tree this would be $k = 2$.

Since the result should obtain $f \equiv f \pi$, the elements touched by one cycle must all be equal.

At the same time different cycles are independent.

Thus for each permutation cycle $\pi$ we can choose one value (among $k$ possible) and thus we get the number of fixed points:

When comparing two necklaces, they can be rotated, but not reversed (i.e. a cyclic shift is permitted).

In this problem we can immediately find the group of invariant permutations:

$$\begin{align}

Let us find an explicit formula for calculating $C(\pi_i)$.

First we note, that the permutation $\pi_i$ has at the $j$-th position the value $i + j$ (taken modulo $n$).

If we check the cycle structure for $\pi_i$.

We see that $1$ goes to $1 + i$, $1 + i$ goes to $1 + 2i$, which goes to $1 + 3i$, etc., until we come to a number of the form $1 + k n$.

Similar statements can be mode for the remaining elements.

Thus the number of cycles in $\pi_i$ will be equal to $\gcd(i, n)$.

Substituting these values into the Pólya enumeration theorem, we obtain the solution:

You can leave this formula in this form, or you can simplify it even more.

Let transfer the sum so that it iterates over all divisors of $n$.

In the original sum there will be many equivalent terms: if $i$ is not a divisor of $n$, then such a divisor can be found after computing $\gcd(i, n)$.

Therefore for each divisor $d ~|~ n$ its term $k^{\gcd(d, n)} = k^d$ will appear in the sum multiple times, i.e. the answer to the problem can be rewritten as

where $C_d$ is the number of such numbers $i$ with $\gcd(i, n) = d$.

We can find an explicit expression for this value.

Any such number $i$ has the form $i = d j$ with $\gcd(j, n / d) = 1$ (otherwise $\gcd(i, n) > d$).

So we can count the number of $j$ with this behavior.

[Euler's phi function](../algebra/phi-function.md) gives us the result $C_d = \phi(n / d)$, and therefore we get the answer:

Thus we can write the implementations to this problem.

using Permutation = vector<int>;

void operator*=(Permutation& p, Permutation const& q) {

There are two formulas for the Catalan numbers: **Recursive and Analytical**. Since, we believe that all the mentioned above problems are equivalent (have the same solution), for the proof of the formulas below we will choose the task which it is easiest to do.

The recurrence formula can be easily deduced from the problem of the correct bracket sequence.

(here $\binom{n}{k}$ denotes the usual binomial coefficient, i.e. number of ways to select $k$ objects from set of $n$ objects).

Therefore the set of all edges has the cardinality $\binom{n}{2}$, i.e. $\frac{n(n-1)}{2}$.

Since any labeled graph is uniquely determined by its edges, the number of labeled graphs with $n$ vertices is equal to:

The root vertex will appear in a connected component of size $1, \dots n-1$.

There are $k \binom{n}{k} C_k G_{n-k}$ graphs such that the root vertex is in a connected component with $k$ vertices (there are $\binom{n}{k}$ ways to choose $k$ vertices for the component, these are connected in one of $C_k$ ways, the root vertex can be any of the $k$ vertices, and the remainder $n-k$ vertices can be connected/disconnected in any way, which gives a factor of $G_{n-k}$).

Therefore the number of disconnected graphs with $n$ vertices is:

And finally the number of connected graphs is:

Based on the formula from the previous section, we will learn how to count the number of labeled graphs with $n$ vertices and $k$ connected components.

This vertex belongs to some component.

If the size of this component be $s$, then there are $\binom{n-1}{s-1}$ ways to choose such a set of vertices, and $C_s$ ways to connect them.After removing this component from the graph we have $n-s$ remaining vertices with $k-1$ connected components.

Therefore we obtain the following recurrence relation: