The Money Changing Problem Revisited - Universität Bielefeld

965
The Money Changing Problem Revisited:
Computing the Frobenius Number
in Time O(ka 1 ) ⋆
Sebastian Böcker and Zsuzsanna Lipták
AG Genominformatik, Technische Fakultät
Universität Bielefeld
PF 100 131
33501 Bielefeld, Germany
{boecker,zsuzsa}@CeBiTec.uni-bielefeld.de
Abstract. The Money Changing Problem (also known as Equality Constrained
Integer Knapsack Problem) is as follows: Let a 1

966 Sebastian Böcker and Zsuzsanna Lipták
a 1 ,a 2 ,a 3 , Greenberg [9] provides a fast algorithm with runtime O(log a 1 ), and
Davison [6] independently discovered a simple algorithm with runtime O(log a 2 ).
Kannan [11] establishes algorithms that for any fixed k, compute the Frobenius
number in time polynomial in log a k . For variable k, the runtime of such algorithms
has a double exponential dependency on k, and is not competitive for
k ≥ 5. Also, it does not appear that Kannan’s algorithms have actually been implemented.
Computing the Frobenius number is NP-hard [15], so we cannot hope
to find algorithms polynomial in k and log a k simultaneously unless P = NP.
There has been a considerable amount of research on computing the exact
Frobenius number if k is variable, see again [16] for a survey. Heap and Lynn [10]
suggest an algorithm with runtime O(a 3 k
log g), and Wilf’s “circle-of-light” algorithm
[18] runs in O(kg) time, where g = O(a 1 a k ) is the Frobenius number of the
problem. Until recently, the fastest algorithm to compute g(a 1 ,...,a k ) was due
to Nijenhuis [14]: It is based on Dijkstra’s method for computing shortest paths
[7] using a priority queue. This algorithm has runtime O(ka 1 log a 1 ) using binary
heaps, and O(a 1 (k+loga 1 )) using Fibonacci heaps as the priority queue. To find
the Frobenius number, the algorithm computes a data structure (called “residue
table” in the following) of a 1 words, which in turn allows simple computation of
g(a 1 ,...,a k ). Nijenhuis’ algorithm requires O(a 1 ) extra memory in addition to
the residue table. Recently, Beihoffer et al. [3] developed algorithms that work
faster in practice, but none obtains asymptotically better runtime bounds than
Nijenhuis’s algorithm, and all require extra memory linear in a 1 .
Here, we present an intriguingly simple algorithm to compute the residue
table – and hence, to find g(a 1 ,...,a k )–intimeO(ka 1 ) with constant extra
memory. In addition to the improved runtime bound, our algorithm also outperforms
Nijenhuis’ algorithm in practice.
Moreover, access to the residue table allows us to solve subsequent MCP
decision problems on the same coin set in constant time: Here, the input is
a 1 ,...,a k ,n and we ask the question “Is n decomposable?” The MCP decision
problem, also known as Equality Constrained Integer Knapsack Problem, is also
NP-hard [13]. In principle, one can solve MCP decision problems using generating
functions, but the computational cost for coefficient expansion and evaluation
are too high in applications [8, Chapter 7.3]. It is computer science folklore
that the question can be answered in time O(kn) using dynamic programming 1 ,
but the linear runtime dependence on n is unfavorable. Aardal et al. [1, 2] use
lattice basis reduction to find a decomposition of n. In Section 6 we show that
computing the complete residue table using our algorithm is often faster than
solving a single MCP decision instance with the method suggested by Aardal
et al.
We show in [4] that a slightly modified version of the algorithm presented
here allows its application for the analysis of mass spectrometry data: There, one
is given a weighted alphabet (such as amino acids) and an input mass m, and
one wants to find all decompositions of m. To this end, an “extended residue
1 Wright [19] shows how to find a decomposition using a minimal number of coins in
time O(kn)

The Money Changing Problem Revisited 967
table” of size O(ka 1 ) is generated in runtime O(ka 1 ), where a 1 is the smallest
mass in the alphabet and k the size of the alphabet. This data structure allows
for computation of all decompositions in time linear in the size of the output,
and otherwise independent of the input mass m. Confer [4] for details.
2 Residue Classes and the Frobenius Number
For integers a and b, let“a mod b” denote the unique integer p ∈{0,...,b− 1}
such that p ≡ a (mod b) holds.
Let a 1 < ···

968 Sebastian Böcker and Zsuzsanna Lipták
p a 1 =5 a 2 =8 a 3 =9 a 4 =12
0 0 0 0 0
1 ∞ 16 16 16
2 ∞ 32 17 12
3 ∞ 8 8 8
4 ∞ 24 9 9
Fig. 1. Table n p for the MCP instance 5, 8, 9, 12
In case all a 2 ,...,a k are coprime to a 1 , this short algorithm is already sufficient
to find the correct values n p . We have displayed a small example in Figure 1,
where every column corresponds to one iteration of the algorithm as described in
the previous paragraph. For example, focus on the column a 3 = 9. We start with
n = 0. In the first step, we have n ← 9andp =4.Sincenn 3 =8
we set n ← 8. Third, we have n ← 8 + 9 = 17 and p =2.Sincenn 1 =16wesetn ← 16. Finally, we return to p =0vian ← 16 + 9 = 25.
From the last column we can see that the Frobenius number for this example
is g(5, 8, 9, 12) = 16 − 5 = 11.
It is straighforward how to generalize the algorithm for d := gcd(a 1 ,a i ) > 1:
In this case, we do the updating independently for every residue r =0,...,d−1:
Only those n p for p ∈{0,...,a 1 − 1} are updated that satisfy p ≡ r (mod d).
To guarantee that the round robin loop completes updating after a 1 /d steps, we
have to start the loop from a minimal n p with p ≡ r (mod d). For r =0we
know that n 0 = 0 is the unique minimum, while for r ≠0wesearchforthe
minimum first.
Round Robin Algorithm
1 initialize n 0 =0andn p = ∞ for p =1,...,a 1 − 1
2 for i =2,...,k do
3 d =gcd(a 1 ,a i );
4 for r =0,...,d− 1do
5 Find n =min{n q | q mod d = r, 0 ≤ q ≤ a 1 − 1}
6 If n 1.
Lemma 1. Suppose that n ′ p for p =0,...,a 1−1 are the correct residue table entries
for the MCP instance a 1 ,...,a k−1 .Initializen p ← n ′ p for p =0,...,a 1 −1.

The Money Changing Problem Revisited 969
Then, after one iteration of the outer loop (lines 3–10) of the Round Robin Algorithm,
the residue table entries equal the values n p for p =0,...,a 1 − 1 for
the MCP instance a 1 ,...,a k .
Since for k =1,n 0 =0andn p = ∞ for p ≠ 0 are the correct values for
the MCP with one coin, we can use induction to show the correctness of the
algorithm. To prove the lemma, we first note that for all p =0,...,a 1 − 1,
n p ≤ n ′ p and n p ≤ n q + a k for q =(p − a k )moda 1
after termination. Assume that for some n, there exists a decomposition n =
∑ k
i=1 a ix i .Wehavetoshown ≥ n p for p = n mod a 1 .Now, ∑ k−1
i=1 a ix i =
n − a k x k is a decomposition of the MCP instance a 1 ,...,a k−1 and for q =
(n − a k x k )moda 1 we have n − a k x k ≥ n ′ q. We conclude
n p ≤ n q + a k x k ≤ n ′ q + a kx k ≤ n.
By an analogous argument, we infer n p = n for minimal such n. One can easily
show that n p = ∞ if and only if no n with n ≡ p (mod a 1 ) has a decomposition
with respect to the MCP instance a 1 ,...,a k .
Under the standard model of computation, time and space complexity of the
algorithm are immediate and we reach:
Theorem 1. The Round Robin Algorithm computes the residue table of an instance
a 1 ,...,a k of the Money Changing Problem, in runtime Θ(ka 1 ) and extra
memory O(1).
To obtain a decomposition of any n in k steps, we save for every p =
0,...,a 1 − 1 the minimal index i such that a decomposition x 1 ,...,x k of n p
has x i > 0, and we also save the maximal x i for any such decomposition. This
can be easily incorporated into the algorithm retaining identical time complexity,
and requires 2a 1 additional words of memory. Doing so, we obtain a lexicographically
maximal decomposition. Note that unlike the Change Making Problem,
we do not try to minimize the number of coins used.
4 Heuristic Runtime Improvements
We can improve the Round Robin Algorithm in the following ways: First, we do
not have to explicitly compute the greatest common divisor gcd(a 1 ,a i ). Instead,
we do the first round robin loop (lines 6–9) for r =0withn = n 0 = p =0until
we reach n = p = 0 again. We count the number of steps t to this point. Then,
d =gcd(a 1 ,a i )= a1
t
and for d>1, we do the remaining round robin loops
r =1,...,d− 1.
Second, for r>0 we do not have to explicitly search for the minimum in
N r := {n q : q = r, r + d, r +2d,...,r+(a 1 − d)}. Instead, we start with n = n r
and do exactly t − 1 steps of the round robin loop. Here, n r = ∞ may hold, so

970 Sebastian Böcker and Zsuzsanna Lipták
we initialize p = r (line 5) and update p ← (p + a i )moda 1 separately in line 7.
Afterwards, we continue with this loop until we first encounter some n p ≤ n in
line 8, and stop there. The second loop takes at most t−1 steps, because at some
stage we reach the minimal n p =minN r and then, n p

The Money Changing Problem Revisited 971
instance of the problem if run in cache memory. For an instance a 1 ,...,a k of
MCP, the runtime t mod of our modified algorithm roughly depends on the values
1/ gcd(a 1 ,a i ):
t mod ≈ t cache +(t mem − t cache )
1
k − 1
k∑
i=2
1
gcd(a 1 ,a i ) .
For random integers u, v uniformly drawn from {1,...,n} we estimate (analogously
to [12], Section 4.5.2)
( )
1
n∑ p 1
n
E
≈
gcd(u, v) d 2 d = p ∑ 1
d 3 = pH(3) n with p =6/π 2 ,
d=1
d=1
where the H n (3) are the harmonic numbers of third order. The H n
(3) form a monotonically
increasing series with 1.2020

972 Sebastian Böcker and Zsuzsanna Lipták
6 Computational Results
We generated 12 000 random instances of MCP, with k =5, 10, 20 and 10 3 ≤
a i ≤ 10 7 . We have plotted the runtime of the optimized Round Robin Algorithm
against a 1 in Figure 3. As expected, the runtime of the algorithm is mostly
independent of the structure of the underlying instance. The processor cache, on
the contrary, is responsible for major runtime differences. The left plot contains
only those instances with a 1 ≤ 10 6 ; here, the residue table of size a 1 appears
to fit into the processor cache. The right plot contains all random instances; for
a 1 > 10 6 , the residue table has to be stored in main memory.
6
RoundRobin
200
RoundRobin
5
Nijenhuis
k=20
Nijenhuis
k=20
4
k=10
150
time [sec]
k=5
3
time [sec]
k=10
100
2
k=5
50
k=20
1
k=20
k=10
k=10
k=5
k=5
0
0 2*10 5 4*10 5 6*10 5 8*10 5 1*10 6 0
0 2*10 6 4*10 6 6*10 6 8*10 6 1*10 7
Fig. 3. Runtime vs. a 1 for k =5, 10, 20 where a 1 ≤ 10 6 (left) and a 1 ≤ 10 7 (right)
To compare runtimes of the Round Robin Algorithm with those of Nijenhuis’
algorithm [14], we re-implemented the latter in C++ using a binary heap as
the priority queue. As one can see in Figure 3, the speedup of our optimized
algorithm is about 10-fold for a 1 ≤ 10 6 , and more than threefold otherwise.
Regarding Kannan’s algorithm [11], the runtime factor k kk > 10 2184 for k =5
makes it impossible to use this approach.
Comparing the original Round Robin Algorithm with the optimized version,
the achieved speedup was 1.67-fold on average (data not shown).
We also tested our algorithm on some instances of the Money Changing
Problem that are known to be “hard”: Twenty-five examples with 5 ≤ k ≤ 10
and 3719 ≤ a 1 ≤ 48709 were taken from [2], along with runtimes given there
for standard linear programming based branch-and-bound search. The runtime
of the optimized Round Robin Algorithm (900 MHz UltraSparc III processor,
C++) for every instance is below 10 ms, see Table 1. Note that in [2], Aardal and
Lenstra do not compute the Frobenius number g but only verify that g cannot
be decomposed. In contrast, the Round Robin Algorithm computes the residue
table of the instance, which in turn allows to answer all subsequent questions
whether some n is decomposable, in constant time. Still and all, runtimes usually
compare well to those of [2] and clearly outperform LP-based branch-and-bound
search (all runtimes above 9000 ms), taking into account the threefold processor
power running the Round Robin Algorithm.

The Money Changing Problem Revisited 973
Table 1. Runtimes on instances from [2] in milliseconds, measured on a 359 MHz
UltraSparc II (Aardal & Lenstra) and on a 900 MHz UltraSparc III (Round Robin)
Instance c1 c2 c3 c4 c5 p1 p2 p3 p4 p5 p6 p7 p8
Aardal & Lenstra 1 1 1 1 1 1 1 2 1 2 1 2 1
Round Robin 0.8 0.9 0.9 1.1 1.6 3.1 1.2 4.9 9.2 4.0 3.4 3.1 2.8
Instance p9 p10 p11 p12 p13 p14 p15 p16 p17 p18 p19 p20
Aardal & Lenstra 3 2 5 12 6 12 80 80 150 120 100 5
Round Robin 0.4 6.5 1.8 2.1 2.4 1.8 2.1 6.4 2.5 3.7 3.2 9.0
7 Conclusion
We have presented the Round Robin Algorithm that generates a residue table
which allows us to find the Frobenius number, as well as to answer whether any
number n can be decomposed, the latter in constant time. The advantages of
our algorithm are (i) its simplicity, making it easy to implement and allowing
further improvements; (ii) its guaranteed worst case runtime of O(ka 1 ), independent
of the structure of the underlying instance; and (iii) its constant extra
memory requirements. To the best of our knowledge, no other algorithm with
worst case runtime O(ka 1 ) is known. In addition, runtimes of the Round Robin
Algorithm compare well to other, more sophisticated approaches, see [3]. It is
rather surprising that despite the simplicity and efficiency of the Round Robin
algorithm, it has not been reported in literature.
Simulations clearly show that the time consuming part of the Round Robin
algorithm is accessing memory. We are currently working on a modification that
performs cache-optimized memory access as described in Section 5, even when
gcd(a 1 ,a i ) is small.
As mentioned in the introduction, we can use a slightly modified version of
the Round Robin Algorithm to compute a data structure, which in turns allows
us to find all decompositions of any input n. To this end, we generate an extended
residue table of size O(ka 1 )inruntimeO(ka 1 ) that stores not only the
“final” column of the residue table, but also all intermediate steps, confer Fig. 1.
If we denote the number of decompositions of n by γ(n), then this data structure
allows us to generate all decompositions in time O(ka 1 γ(n)) backtracking
through the extended residue table, see [4].
Acknowledgments
Implementation and simulations by Henner Sudek. We thank Stan Wagon and
Albert Nijenhuis for helpful discussions.
References
1. K. Aardal, C. Hurkens, and A. K. Lenstra. Solving a system of diophantine equations
with lower and upper bounds on the variables. Math. Operations Research,
25:427–442, 2000.

974 Sebastian Böcker and Zsuzsanna Lipták
2. K. Aardal and A. K. Lenstra. Hard equality constrained integer knapsacks. Lect.
Notes Comput. Sc., 2337:350–366, 2002.
3. D. E. Beihoffer, J. Hendry, A. Nijenhuis, and S. Wagon. Faster algorithms for
Frobenius numbers. In preparation.
4. S. Böcker and Zs. Lipták. Efficient mass decomposition. In Proc. of ACM Symposium
on Applied Computing 2005, pages 151–157, Santa Fe, USA, 2005.
5. A. Brauer and J. E. Shockley. On a problem of Frobenius. J. Reine Angew. Math.,
211:215–220, 1962.
6. J. L. Davison. On the linear diophantine problem of Frobenius. J. Number Theory,
48(3):353–363, 1994.
7. E. Dijkstra. A note on two problems in connexion with graphs. Numerische
Mathematik, 1:269–271, 1959.
8. R. L. Graham, D. E. Knuth, and O. Patashnik. Concrete Mathematics. Addison-
Wesley, Reading, Massachusetts, second edition, 1994.
9. H. Greenberg. Solution to a linear diophantine equation for nonnegative integers.
J. Algorithms, 9(3):343–353, 1988.
10. B. R. Heap and M. S. Lynn. A graph-theoretic algorithm for the solution of a
linear diophantine problem of Frobenius. Numer. Math., 6:346–354, 1964.
11. R. Kannan. Lattice translates of a polytope and the Frobenius problem. Combinatorica,
12:161–177, 1991.
12. D. E. Knuth. The Art of Computer Programming: Seminumerical Algorithms,
volume 2. Addison-Wesley, Reading, Massachusetts, third edition, 1997.
13. G. S. Lueker. Two NP-complete problems in nonnegative integer programming.
Technical Report TR-178, Department of Electrical Engineering, Princeton University,
March 1975.
14. A. Nijenhuis. A minimal-path algorithm for the “money changing problem”. Amer.
Math. Monthly, 86:832–835, 1979. Correction in Amer. Math. Monthly, 87:377,
1980.
15. J. L. Ramírez-Alfonsín. Complexity of the Frobenius problem. Combinatorica,
16(1):143–147, 1996.
16. J. L. Ramírez-Alfonsín. The Diophantine Frobenius Problem. Oxford University
Press, 2005. To appear.
17. J. J. Sylvester and W. J. Curran Sharp. Problem 7382. Educational Times, 37:26,
1884.
18. H. S. Wilf. A circle-of-lights algorithm for the “money-changing problem”. Amer.
Math. Monthly, 85:562–565, 1978.
19. J. W. Wright. The change-making problem. J. Assoc. Comput. Mach., 22(1):125–
128, 1975.