Unranking Small Combinations of a Large Set in Co-Lexicographic Order

Abstract

The presented research is devoted to the problem of developing new combinatorial generation algorithms for combinations. In this paper, we develop a modification of Ruskey’s algorithm for unranking m-combinations of an n-set in co-lexicographic order. The proposed modification is based on the use of approximations to make a preliminary search for the values of the internal parameter k of this algorithm. In contrast to the original algorithm, the obtained algorithm can be effectively applied when n is large and m is small because the running time of this algorithm depends only on m. Furthermore, this algorithm can be effectively used when n and m are both large but $n-m$ is small, since we can consider unranking $(n-m)$-combinations of an n-set. The conducted computational experiments confirm the effectiveness of the developed modification.

1. Introduction

Combinatorial algorithms are algorithms for investigating combinatorial structures. The development of combinatorial algorithms is one of the basic tasks in computer science [1,2]. Such algorithms provide efficient methods for processing information presented as a discrete structure. For example, it can be combinatorial objects like combinations, permutations, partitions, graphs, trees, etc. [1].

In designing combinatorial algorithms, special attention is paid to the procedure for traversing all possible elements of a given combinatorial set. This problem can be studied as enumerating (counting the total number of elements), listing (making and recording the complete list of all elements), and generating (constructing all the required elements and their sequential visiting) combinatorial objects [2]. Computer programs that use combinatorial algorithms often need to present combinatorial objects one-by-one in the computer memory in the form of a certain data structure and process them. With this approach, there is no need to store the entire list of elements of combinatorial sets, which often have a huge cardinality. Hence, look at the generation of combinatorial objects in more detail since combinatorial generation algorithms are able to solve this problem [3].

In combinatorial generation, the following four problems are distinguished [4]:

• Listing is the process of generating all elements of a combinatorial set sequentially.
• Ranking is the process of getting the rank r of a combinatorial object a (the position of the object in their ordering).
• Unranking is the inverse process of ranking, and unranking algorithms allow to generate the object a that has a rank r.
• Random selection is the process of generating elements of a combinatorial set in a random order.

In this paper, we consider the combinatorial generation of m-combinations of an n-set ($0\le m\le n$). An m-combination of an n-set is a subset of m distinct elements selected from a set of n elements. The total number of all m-combinations of an n-set can be calculated using the binomial coefficient $\left(\genfrac{}{}{0pt}{}{n}{m}\right)$. There are two main ways to represent such combinations. One possible way of representing an m-combination of an n-set is the increasing sequence $c=\left(c_1,c_2,\dots ,c_m\right)$ of the selected elements in this combination, where $1\le c_1<\cdots <c_m\le n$. Another way of representing an m-combination of an n-set is the binary sequence $b=\left(b_1,b_2,\dots ,b_n\right)$, where $b_1+b_2+\dots +b_n=m$, $b_i=1$ encodes that the i-th element is selected and $b_i=0$ encodes that the i-th element is not selected in this combination.

There are many different algorithms for generating all combinations with different orderings. Akl [5] conducted a computational experiment to compare the speed of such algorithms that were developed before 1980. During the experiment, the following nine algorithms for generating all combinations were implemented in Fortran: algorithms of Bitner et al., Chase, Ehrlich, Kurtzberg, Lehmer, Liu and Tang, Mifsud, Nijenhuis and Wilf, Payne and Ives. The results of the experiment showed that Mifsud’s algorithm [6] was the fastest. The next stage in obtaining new algorithms for the fast generation of combinations is shown in the active use of parallel computing (see [7,8,9,10,11,12,13,14,15,16]). Such parallel algorithms use m processors and allow to produce combinations in constant time per combination. In addition to algorithms that provide fast generation of combinations, there are studies aimed at reducing the required memory space for calculations. For example, Itai [17] presented an algorithm to produce combinations in lexicographic order that required only $O\left(1\right)$ extra storage, but non-constant time.

There are also studies on the development of algorithms for generating all combinations that provide some useful properties due to applying a special ordering of the generated combinations. For example, there are algorithms that use a special ordering of the generated combinations in which the strong minimal change property holds (see algorithms of Eades and McKay [18], Xiang [19], Torres-Jimenez and Izquierdo-Marquez [20]). The main goal of these algorithms is to reduce the number of changes when generating combinations represented as increasing sequences of the selected elements in the combination and, as a result, to produce such combinations in constant time per combination or in constant space. Another interesting way to order the generated combinations was proposed by Ruskey and Williams [21]. This order called cool-lex order is a Gray code order that is based on the use of prefix shift operations.

However, there are situations in which it is necessary to generate a certain object again without generating all the objects that precede it. For this purpose, there are special combinatorial generation algorithms for ranking and unranking combinatorial objects. Such algorithms for ranking and unranking m-combinations of an n-set in lexicographic order were first presented by Knott [22]. Next, Er [23] proposed new ranking and unranking algorithms with $O(n-m)$ and $O\left(n\right)$ time complexity (without taking into account the time for calculating the binomial coefficients), respectively. These algorithms are shorter and simpler than Knott’s corresponding algorithms due to representing combinations as binary sequences. The following algorithms for unranking m-combinations of an n-set were developed by Kokosinski [24]:

• UNRANKCOMB-A: decreasing lexicographical order, $O\left(n\right)$ time complexity and $O\left(nm\right)$ space complexity;
• UNRANKCOMB-B: increasing lexicographical order, $O\left(n\right)$ time complexity and $O\left(nm\right)$ space complexity;
• UNRANKCOMB-C: decreasing lexicographical order, $O(mlogn)$ time complexity and $O\left(nm\right)$ space complexity;
• UNRANKCOMB-D: decreasing lexicographical order, $O\left(n\right)$ time complexity and $O\left(m\right)$ space complexity.

Kokosinski [25] also presented the first parallel algorithm for unranking combinations. This algorithm called UNRANKCOMB-E requires n processors and has $O\left(m\right)$ time complexity. Additionally, this parallel algorithm has the preprocessing step for calculating and storing the binomial coefficients with $O\left(n\right)$ time complexity and $O\left(nm\right)$ space complexity.

There are also studies on the development of algorithms for ranking and unranking combinations by applying some general approach. For example, Ryabko [26] described methods for encoding and decoding combinatorial objects represented as sequences by calculating the number of all sequences prefixes. Applying this approach, new algorithms for ranking and unranking m-combinations of an n-set in lexicographical order were obtained. These algorithms use binary sequences to represent combinations and have $O(n{log}^{3}nloglogn)$ time complexity and $O\left(n{log}^{2}n\right)$ space complexity. Shablya et al. [27] presented another general approach for developing new combinatorial generation algorithms. This method, which is based on the use of AND/OR trees for representing combinatorial sets, allows the development of new algorithms for listing, ranking and unranking combinations in co-lexicographic order. Such ranking and unranking algorithms also use binary sequences to represent m-combinations of an n-set and have $O(n+m^2)$ and $O\left(nm\right)$ time complexity, respectively. Genitrini and Pepin [28] proposed a way to improve ranking and unranking algorithms that are based on calculating binomial coefficients. The main idea is to calculate new binomial coefficients using the binomial coefficients obtained in the previous steps. The effectiveness of this approach was tested on several well-known algorithms for unranking combinations and a new algorithm for unranking combinations in lexicographic order, which is based on the factoradic numeral system.

In addition, there are studies dedicated to the special case of developing new efficient algorithms for ranking and unranking m-combinations of an n-set where the obtained algorithms are independent of n. Hence, such algorithms are effective when n is large and m is small. For example, Shimizu et al. [29] presented $O\left(m^{3m+3}\right)$-time ranking and unranking algorithms. These algorithms use several bijections from the set of combinations to other finite sets. Moreover, the order of the generated combinations is not one of the well-known variants for ordering the elements of combinatorial sets.

Parque and Miyashita [30,31] introduced another approach for unranking small combinations of large sets by using a gradient-based optimization algorithm. The order of the generated m-combinations of an n-set is the revolving door order starting with $(1,2,\dots ,m-1,m)$ and ending with $(1,2,\dots ,m-1,n)$. To search for each element $c_i$ of the combination $c=\left(c_1,c_2,\dots ,c_m\right)$, it is necessary to solve a constrained minimization problem by a gradient-based optimization. This unranking algorithm has $O\left(m^2\right)$ time complexity when using a single processor, and $O(mlogm)$ when using at most $O(m/logm)$ processors. However, there is no information about any algorithm for ranking combinations in this order.

This paper focuses on unranking small m-combinations of a large n-set with using co-lexicographic order. The organization of this paper is as follows. Section 2 presents a brief description of a way for ranking and unranking combinations in co-lexicographic order and a detailed description of the proposed modification of the original unranking algorithm. In Section 3 we confirm the effectiveness of the proposed modification by performing several computational experiments and obtaining the computational complexity for the presented algorithm.

2. Materials and Methods

2.1. Algorithms for Ranking and Unranking Combinations in Co-Lexicographic Order

There are several variants for ordering any list of strings or sequences, for example, the well-known lexicographic and co-lexicographic orders [2]. Lexicographic (lex) order is a such order in which $a_1,a_2,\dots ,a_n<b_1,b_2,\dots ,b_m$ if $n=m$ and there exists $k\in \{1,\dots ,n\}$ satisfying $a_k<b_k$ and $a_i=b_i$ for every $i<k$ or if $n<m$ and $a_i=b_i$ for $i\le n$. Co-lexicographic (colex) order is a such order in which $a_1,a_2,\dots ,a_n<b_1,b_2,\dots ,b_m$ if $a_n,\dots ,a_2,a_1<b_m,\dots ,b_2,b_1$ in lex order.

Lex order is a natural and clear way of ordering. At the same time, colex order can make combinatorial algorithms shorter, faster, more elegant and natural [4]. For ranking a combination $c = \left(c_1,c_2,\dots ,c_m\right)$ in colex order, we can use the next formula (Equation (4.10) in [4]):

$$\mathtt{RankColex}\left(c\right)=\sum _{i=1}^m\left(\genfrac{}{}{0pt}{}{c_i-1}{i}\right).$$

(1)

Applying (1), it is possible to calculate the rank of a given m-combination of an n-set fast, even for large n since it is independent of n. Let us consider the following algorithm for unranking combinations in colex order (Algorithm 4.10 in [4]):

For a given m-combination of an n-set, Algorithm 1 takes the number m of the selected elements and the rank $r<\left(\genfrac{}{}{0pt}{}{n}{m}\right)$ of the combination in colex order as input. As a result, the values of the selected elements $c_i$ in the combination will be obtained in the form of a sequence $\left(c_1,c_2,\dots ,c_m\right)$. The main idea of this algorithm for unranking combinations in colex order is as follows. First, for the case $k=m$, we search for the interval that contains the rank r among the following binomial coefficients:

$$\left(\genfrac{}{}{0pt}{}{m}{m}\right)+\left(\genfrac{}{}{0pt}{}{m+1}{m}\right)+\left(\genfrac{}{}{0pt}{}{m+2}{m}\right)+\dots +\left(\genfrac{}{}{0pt}{}{n}{m}\right)=\left(\genfrac{}{}{0pt}{}{n+1}{m+1}\right).$$

(2)

Algorithm 1: Algorithm for unranking combinations in colex order

It is easy to see that the number of terms on the left in (2) is $n-m+1$. If we know the rank r of an m-combination of an n-set and the solution for

$$\left(\genfrac{}{}{0pt}{}{k-1}{m}\right)\le r<\left(\genfrac{}{}{0pt}{}{k}{m}\right),$$

(3)

then the m-th selected element in the combination is equal to k. Next, we need to get the $(m-1)$-th selected element in the combination by searching for the interval that contains the rank

$$r:=r-\left(\genfrac{}{}{0pt}{}{k-1}{m}\right).$$

(4)

Thus, solving (3) and applying (4), we can sequentially find the values of the selected elements of the m-combination with the rank r. For $m<n-m$, the computational complexity of Algorithm 1 is $O\left(m^2·(n-m)\right)$ which was obtained on the basis of the following information:

• the number of iterations in the for-loop (Line 2 in Algorithm 1) is m;
• the minimum number of comparisons in the while-loop (Line 4 in Algorithm 1) is $n-m+1$ (when $i=m$) and the maximum number of comparisons is n (when $i=1$);
• the computational complexity of calculating the value of a binomial coefficient $\left(\genfrac{}{}{0pt}{}{n}{m}\right)$ is $O\left(m\right)$ when $m<n-m$ and $O(n-m)$ when $m>n-m$.

For large n and small m, the number of intervals in (3) that can contain the required rank r is large due to the dependence on n. The goal of our improvements of Algorithm 1 is to reduce the number of comparisons in the while-loop (Line 4 in Algorithm 1). For this purpose we need to find the solution of (3) fast.

2.2. Modification of Unranking Algorithm

Let us change Algorithm 1 by adding a function $\mathtt{FindK}(r,m)$ for preliminary search for the value of k. This function should calculate the approximate value of k for solving the inequality (3); however, the obtained value of k must not be greater than the true value of the solution of this inequality. Thus, we get an algorithm for unranking combinations in colex order (Algorithm 2).

Algorithm 2: Modification of algorithm for unranking combinations in colex order

Next, we consider the development of the function $\mathtt{FindK}(r,m)$ for Algorithm 2 in more detail.

A binomial coefficient can be presented as

$$\left(\genfrac{}{}{0pt}{}{n}{m}\right)=\frac{n(n-1)(n-2)\cdots (n-m+1)}{m!}.$$

(5)

Using (3) and (5), we get

$$r<\frac{k(k-1)(k-2)\cdots (k-m+1)}{m!}.$$

After some transformations, we obtain the following inequality:

$$\sqrt[m]{k(k-1)(k-2)\cdots (k-m+1)}>\sqrt[m]{rm!}.$$

(6)

If we consider the inequality of arithmetic and geometric means [32] for the list of numbers $k,(k-1),(k-2),\dots ,(k-m+1)$, then we get

$$\frac{k+(k-1)+(k-2)+\dots +(k-m+1)}{m}\ge \sqrt[m]{k(k-1)(k-2)\cdots (k-m+1)}.$$

After some simplifications on the left, we obtain

$$k-\frac{m-1}{2}\ge \sqrt[m]{k(k-1)(k-2)\cdots (k-m+1)}.$$

(7)

Combining (6) and (7), we get

$$k-\frac{m-1}{2}>\sqrt[m]{rm!}$$

or

$$k>\sqrt[m]{rm!}+\frac{m-1}{2}.$$

Hence,

$$k\approx ⌈\sqrt[m]{rm!}+\frac{m-1}{2}⌉.$$

(8)

Thus, applying (8), we can find an approximate value of k for which the next inequality is true:

$$r<\left(\genfrac{}{}{0pt}{}{k}{m}\right).$$

(9)

We also use the following Stirling’s approximation [33] for calculating the factorial in (8):

$$n!\approx \sqrt{2\pi n}{\left(\frac{n}{e}\right)}^n{e}^{\frac{1}{12n}-\frac{1}{360n^3}}.$$

(10)

Using the approximate Formula (10) in (8) and making some transformations, we obtain the following approximate formula for k:

$$k\approx ⌈m{e}^{\frac{logr}{m}+\frac{log2\pi m}{2m}+\frac{1}{12m^2}-\frac{1}{360m^4}-1}+\frac{m-1}{2}⌉.$$

(11)

This approximate formula can be used in the preliminary search for the value of k. That is, the Formula (11) can be applied as the basis of the function $\mathtt{FindK}(r,m)$ (Line 3 in Algorithm 2).

3. Results

We have performed a computational experiment for checking the obtained Formula (11). For this purpose we set the number of selected elements m in the range of 10 to 200 and the rank r in the range of ${10}^{100}$ to ${10}^{200}$. For these values of m and r, we have the distribution of values of n in the range of 332 (when $m=170$ and $r={10}^{100}$) to $4.5\ast {10}^{20}$ (when $m=10$ and $r={10}^{200}$). Then we calculate the difference between the value of k obtained by using the approximate Formula (11) and the value of k obtained by using the while-loop (Line 4 in Algorithm 1). The results of the computational experiment are presented in

Table 1. Errors in determining the value of k depending on the values of m and r.

	r	${10}^{100}$	${10}^{110}$	${10}^{120}$	${10}^{130}$	${10}^{140}$	${10}^{150}$	${10}^{160}$	${10}^{170}$	${10}^{180}$	${10}^{190}$	${10}^{200}$
m
10		0	0	0	0	0	0	0	0	0	1	1
20		0	0	0	0	0	0	0	0	0	1	1
30		0	0	0	0	0	0	0	0	0	0	0
40		0	0	0	0	0	0	0	0	0	0	0
50		0	0	0	0	0	0	0	0	0	0	0
60		1	0	0	0	0	0	0	0	0	0	0
70		0	0	0	0	0	0	0	0	0	0	0
80		1	0	0	0	0	1	0	0	0	0	0
90		1	1	0	1	0	0	0	1	0	0	0
100		1	1	1	1	1	1	0	0	0	0	0
110		2	1	1	0	1	1	1	0	0	0	0
120		2	1	1	1	1	1	0	0	1	0	1
130		3	2	2	1	1	1	1	0	0	1	0
140		3	3	2	1	1	1	1	1	1	1	0
150		4	3	3	3	2	1	2	2	1	1	1
160		4	4	3	2	2	2	2	1	1	1	1
170		5	4	4	4	3	2	3	2	2	1	2
180		5	5	5	4	3	3	2	2	2	2	2
190		7	6	5	5	3	3	3	3	2	2	2
200		7	6	6	5	5	4	3	3	3	2	2

.

From Table 1 we can see that the errors are small. Note that increasing r reduces the errors, but increasing m raises the errors. It is explained by the use of the approximate Formulas (8) and (10) for calculations. Moreover, we can not use the approximate Formula (11) for small m because the application of (10) to such values of m leads to an increase in errors. Therefore, for small m we can find the values of k by solving an equation obtained from (9):

If $m=1$, then we get

$$r<\left(\genfrac{}{}{0pt}{}{k}{1}\right).$$

In this case, we can use the following initial condition for the value of k:

$$k=r.$$

If $m=2$, then we get

$$r<\left(\genfrac{}{}{0pt}{}{k}{2}\right)$$

or

$$k^2-k-2r>0.$$

In this case, we can use the following initial condition for the value of k:

$$k=⌈\frac{1+\sqrt{1+8r}}{2}⌉.$$

For other small values of m we can use other approximate formulas for solving (9), for example, it can be the approximate Formula (8). Hence, we obtain an algorithm for preliminary search for the values of k (Algorithm 3). In this algorithm, the parameter s shows the boundary value of m for applying the approximate Formula (11).

Algorithm 3: Preliminary search for the values of k for Algorithm 2

Algorithm 2 with the use of Algorithm 3 has $O(m·(m+\epsilon m))\approx O\left(m^2\right)$ time complexity (assuming algebraic operations with numbers in $O\left(1\right)$). This is determined by the number m of iterations in the for-loop (Line 2 in Algorithm 2) where each loop requires:

• preliminary search for the value of k (Line 3 in Algorithm 2) by using Algorithm 3 that has $O\left(m\right)$ time complexity;
• search for the true value of k by making $\epsilon$ iterations in the while-loop (Line 4 in Algorithm 2);
• calculation of the value of a binomial coefficient $\left(\genfrac{}{}{0pt}{}{n}{m}\right)$ that has $O\left(m\right)$ time complexity when $m<n-m$.

The parameter $\epsilon$ is the error in determining the value of k that is substantially smaller than n (see Table 1). Hence, the modified Algorithm 2 has the polynomial complexity that depends only on m. In the case when n is large and m is small, this algorithm will be better than the original Algorithm 1 due to the independence of n in its complexity.

We have also performed a computational experiment aimed at comparing the obtained algorithm for unranking small combinations of a large set in colex order with Parque and Miyashita’s unranking algorithm [30,31]. For this purpose we set the number of selected elements m in the range of 10 to 100 and generate 20 different m-combinations of an n-set with uniformly distributed ranks r in the range of 0 to $\left(\genfrac{}{}{0pt}{}{n}{m}\right)-1$. We implemented these algorithms in the computer algebra systems Maxima on a laptop (Intel i7-9750H, 2.6 GHz, Windows 10, 64 bit). Figure 1 and Figure 2 present average time to generate each combination for $n=500$ and $n=1000$. Note that both algorithms show similar results. However, there is a difference in the way the combinations are ordered and in the availability of the ranking algorithm.

4. Conclusions

In this paper, we have presented a modification of the algorithm for unranking m-combinations of an n-set in colex order described in [4]. The computational complexity of the modified Algorithm 2 for unranking combinations in colex order with the use of Algorithm 3 for preliminary search for the values of k is $O(m·(m+\epsilon m))\approx O\left(m^2\right)$ (assuming algebraic operations with numbers in $O\left(1\right)$).

In contrast to the original Algorithm 1, the obtained Algorithm 2 can be effectively applied when n is large and m is small because the running time of this algorithm depends only on m. When n and m are both large but $n-m$ is small, then we can consider unranking $(n-m)$-combinations of an n-set. If we mark the selected elements in the $(n-m)$-combination of an n-set as the unselected elements in the m-combination of an n-set, then we obtain the original m-combination.