O(1) Time Generation of Adjacent Multiset Combinations

We solve the problem of designing an O(1) time algorithm for generating adjacent multiset combinations in a different approach from Walsh. By the word adjacent, we mean that two adjacent multiset combinations are different at two places by one in their vector forms. Previous O(1) time algorithms for multiset combinations generated non-adjacent multiset combinations. Our algorithm in this paper can be derived from a general framework of combinatorial Gray code, which we characterise to suit our need for combinations and multiset combinations. The central idea is a twisted lexico tree, which is obtained from the lexicographic tree for the given set of combinatorial objects by twisting branches depending on the parity of each node. An iterative algorithm which traverses this tree will generate the given set of combinatorial objects in constant time as well as with a fixed number of changes from the present combinatorial object to the next.

💡 Research Summary

The paper addresses the long‑standing problem of generating multiset combinations in constant time while guaranteeing adjacency, i.e., each successive combination differs in exactly two positions by ±1 in its vector representation. Traditional O(1) algorithms, such as the one proposed by Walsh, produce Gray‑code‑like sequences but are “non‑adjacent”: a transition may modify many components at once, which is undesirable for applications that require minimal change between states (e.g., real‑time scheduling, hardware pipelines, cryptographic key rotation).

The authors introduce a novel combinatorial framework called the twisted lexico tree. Starting from the ordinary lexicographic tree that enumerates all k‑length selections from a multiset, they assign a parity (even/odd) to each node based on the depth (or the number of 1‑bits in the depth index). The parity determines the direction in which the children of a node are visited: even‑parity nodes are traversed left‑to‑right (ascending order), while odd‑parity nodes are traversed right‑to‑left (descending order). This systematic “twist” forces the traversal to behave like a Gray code: when moving from one leaf to the next, only two coordinates change, each by exactly one unit.

The algorithm is fully iterative. It maintains two arrays: **A