Although the page size used in a storage hierarchy is
typically fixed when the subsystem is designed, it is
possible to simulate a variable size page by fetching a
group of contiguous pages in the address space whenever
one of them is referenced [3, 9, 12, 14]. Perhaps the
number of pages included in a group could be varied
dynamically to ensure that the value of the fraction half-
referenced is kept within a desirable range.
It may therefore be possible that the fraction half-
referenced could be dynamically measured during the
operation of a storge hierarchy, and used as a feedback
parameter to control the extent to which future storage
references are predicted when a page fault occurs by
transferring a variable number of pages, and also to
control the residence periods of those pages by adjusting
the number of first level storage page frames allocated to
each executing process.
Received 8/79; revised 5/80; accepted 6/81
References
I. Baer, J. L., and Sager, G. R. Measurements and improvement of
program behaviour under paging systems. Statistical Computer
Performance Evaluation. W. Freiberger (Ed.), Academic Press, New
York, 1972, 241-265.
2. Belady, L. A. A study of replacement algorithms for a virtual
storage computer. I B M Sys. J. 5, 2 (1966) 78-101.
3. Bennett, B. T., and Franaszek, P. A. Permutation clustering: An
approach to on-line storage reorganization. I B M J. Res. and Develop.
21, 6 (Nov. 1977) 528-533
4. Boon, C., and Bunyan, C. J., Eds., Virtual storage, lnfotech State
of the Art Report, Infotech International Ltd., Nicholson House,
Maidenhead, Berkshire, England, 1976.
5. Chu, W. W., and Opderbeck, H. Performance of replacement
algorithms with different page sizes. IEEE Computer 7, 11 (Nov.
1974) 14-21.
6. Conti, C. J. Concepts for buffer storage. 1EEE Computer Group
News. 2, 8 (Mar. 1969) 9-13.
7. Denning, P. J. Virtual memory. Comp. Surv. 2, 3 (Sept. 1970),
153-189.
8. Doran, R. W. Virtual memory. IEEE Computer. 9, 10 (Oct. 1976)
27-37.
9. Doyle, M. S. The effects of program behaviour on the design of
storage hierarchies. Research Report CSRR-2071, Department of
Applied Analysis and Computer Science, University of Waterloo,
Ontario, Canada (Aug. 1972).
10. Easton, M. C., and Fagin, R. Cold start vs warm start miss ratios.
Comm. A C M 21, 10 (Oct. 1978) 866-872.
I 1. Ferrari, D. Program behaviour. 1EEE Computer, 9, 11 (Nov.
1976) 7-8.
12. Franaszek, P. A., and Bennett, B. T. Adaptive variation of the
transfer unit in a storage hierarchy. 1BM J. Res. and Devel. 22, 4
(July 1978) 405-412.
13. Hatfield, D. J. Experiments on page size, program access
patterns, and virtual memory performance. IBM J. Res. and Develop.
16, I (Jan. 1972) 58-66.
14. Joseph, M. An analysis of paging and program behaviour. The
Computer Journal. 13, 1 (Feb. 1970)48-54.
15. Kuck, D. J., and Lawrie, D. FI. The use and performance of
memory hierarchies; A survey. Report No. 363, Department of
Computer Science, University of Illinois at Champaign-Urbana (Dec.
1969).
16. Liptay, J. S. Structural aspects of the System/360 model 85--The
cache. I B M Sys. J. 7, 1 (1968), 15-21.
17. Mattson, R. L., et al. Evaluation techniques for storage
hierarchies. IBM Sys. J. 9, 2 (1970) 78-117.
18. Spirn, J. Program Behaviour: Models and Measurements. Elsevier-
North Holland, New York, (1977).
555
Programming Techniques M. Douglas Mcllroy*
and Data Structures Editor
Three New Combination
Algorithms with the
Minimal Change Property
Clement W. H. Lam and Leonard H. Soicher
Concordia University
A combination is a k-subset of an n-set. Classical
algorithms to generate all the combinations with the
minimal change and loopless properties were usually
complicated because they required special arrays in order
to achieve the ioopless property. Three algorithms to
generate combinations with the minimal change property
are presented. The first one is obtained by making a
simple change to the ordinary method of recursive gen-
eration of combinations in reverse lexicographical order.
The second algorithm, which has the ioopless property,
is obtained from the first one by using an ordinary stack
to remove the recursion. The third algorithm is an opti-
mized version of the second one. By timing comparisons,
this final algorithm is considerably faster than the pre-
viously published combination algorithms, especially
when k is small compared to n.
CR Categories and Subject Descriptors: G.2.1 [Dis-
crete Mathematics]: Combinatorics--combinatorial
algorithms; F.2.2 [Analysis of Algorithms and Problem
Complexity]: Nonnumerical Algorithms and Problems--
computations on discrete structures
General Term: Algorithms
Additional Key Words and Phrases: combinations, sub-
sets, minimal change, loopless algorithms
This research was supported in part by the Natural Sciences and
Engineering Research Council, Canada and the Ministry of Education
of Quebec.
* Former editor of Programming Techniques and Data Structures,
of which Ellis Horowitz is the current editor.
Authors' Present Addresses: Clement W.H. Lain, Department of
Computer Science, Concordia University, 1455 Maisonneuve Blvd
West, Montreal, Quebec, Canada H3G IM8; Leonard H. Soicher,
University of Cambridge, Department of Pure Mathematics and Math-
ematical Statistics, 16 Mill Lane, Cambridge CB2 ISB, England.
Permission to copy without fee all or part of this material is
granted provided that the copies are not made or distributed for direct
commercial advantage, the ACM copyright notice and the title of the
publication and its date appear, and notice is given that copying is by
permission of the Association for Computing Machinery. To copy
otherwise, or to republish, requires a fee and/or specific permission.
© 1982 ACM 0001-0782/82/0800-0555 $00.75.
Communications August 1982
of Volume 25
the ACM Number 8
1. Introduction
A combination is a k-subset of an n-set. A combina-
tion generation has the minimal change property if every
combination, except the first, is obtained from the pre-
vious combination by replacing only one element. As
introduced by Ehrlich [2, 3], a combination algorithm is
loopless if the maximum number of operations required
to generate each combination, except the first one, is a
constant independent of n and k. We assume throughout
this paper that the underlying n-set is {1, 2 . . . . . n} and
that n_> k > 0.
Our work is motivated by the algorithm of Bitner
et al. [1], which was the most efficient and simplest
method published in the generation of combinations
with the minimal change and loopless properties. The
description of this algorithm is repeated in [5], which
also contains a summary of other combination algori-
thms published. Bitner's algorithm is based on the binary
reflected Gray code and uses a special implementation
of a stack in order to achieve the loopless property.
Interestingly, we can show that our algorithms generate
combinations in the same order as Bitner's if k is even
and in the reverse order if k is odd. However, our
Algorithm 1 is based on making a minor change to the
usual recursive method that generates combinations in
reverse lexicographical order. This change destroys the
ordering and the generated combinations then have the
minimal change property. The second algorithm uses
only a standard stack to eliminate recursion and to
achieve the loopless property. The final algorithm is an
optimized version of the second one, obtained by treating
separately some frequently occurring cases and by im-
plementing a special stack as in Bitner's algorithm. In
our test runs, our Algorithm 3 is 9 times faster than
Bitner's algorithm when n = 24, k = 6.
All the algorithms were coded in Pascal and tested
extensively on a CDC Cyber 172/2. The programs are
available from the authors.
2. The Three Algorithms
In this paper, the algorithms are presented in Pascal.
A k-subset is represented by a global array a [ 1 . . k] of
integers. The d u m m y element a[k + 1] is often used to
store the value n + 1. Every time a combination is
generated, the procedure PROCESS is called to process
that combination.
It is clear that all the k-subsets can be generated in
reverse lexicographical order by k nested loops. These
nested loops can be reduced to a single loop by using
recursion. Algorithm 1 is obtained by insisting that the
loop which controls the generation of the element a[i]
shall depend on the parity of the index variable i. This
algorithm will have the minimal change property.
556
Algorithm 1. Recursive generation of combinations with
minimal change property.
procedure ALGOR1 ( i : integer);
v a r j : integer;
begin
if i rood 2 = 0
then
for j := i to a[i+ 1] - 1 do
begin a[i] : = j ; A L G O R I ( i - 1 ) end
else
f o r j := a[i+l] - 1 downto i do
begin a[i] : = j ;
i f / = 1 then PROCESS else ALGOR1 ( i - 1 )
end
end; (* A L G O R I *)
After assigning the value n + 1 to a[k + 1], the initial
call to generate all the combinations is A L G O R I (k).
It is a simple exercise to prove that Algorithm 1
generates all the different k-subsets of the n-set {1,
2 . . . . . n}. We shall now prove that it has the minimal
change property. First of all, we give the following
definitions.
Let a[l .. k] be a combination with a[k + l] = n +
1. For l __ i <_ k, we define
i if i is even,
start(/)= a[i+ 1 ] - 1 if iisodd,
= (a[i + l] - 1 if i is even,
stop (i) if i is odd.
The element a[i] is said to be moveable if a[i] ~ stop (i).
The idea o f moveability is intimately related to the
execution of Algorithm 1. After returning from the pro-
cedure PROCESS, the next combination is generated by
backing up the recursion stack until an i is found such
that a[i] is moveable. The element a[/] is changed and
A L G O R 1 is then called recursively until i = 1. The next
combination is then available. We now show that this
new combination differs from the previous one by re-
placing one element.
THEOREM 2.1. Algorithm 1 has the minimal change prop-
erty.
PROOF. Let a l l . . k ] be a given combination. If none of
the a[i]'s is moveable, the algorithm terminates. Other-
wise, let a[i] be the moveable element with the smallest
index. In other words, a[j] = stop(j) for all j < i and
a[i] ~ stop(i). It is clear that the next combination is
obtained without changing any a[j] where j > i. The
element a[i] is either increased by l or decreased by 1
depending on the parity of i. The remaining elements
a[j], j < i, are assigned the value start ( j ) in decreasing
order o f j . Table I summarizes the differences between
the old and the new combinations.
If i > l, then the new combination differs from the
old one either by replacing i - l by x + 1 or by replacing
x by i - l, depending on the parity of i. If i = 1 then x
Communications August 1982
of Volume 25
the ACM Number 8
Table 1. The Effect of Generating a N e w C o m b i n a t i o n W h e n a[i] is
the Moveable Element with the Smallest Index.
i even i odd
old new old
a[i] x x + 1 x x-
a[i--l] i-- 1 x x- 1
a[i-- 2] i-- 2 i-- 2 i-- 2
a[l] 1 1 1 1
is replaced by x - 1. Hence, the algorithm has the
minimal change property. []
The preceding proof describes the necessary changes
to go from one combination to the next, provided that
the moveable element with the smallest index is known.
The standard method to eliminate the recursion in Al-
gorithm 1 would be to push the index i of each recursive
call, in decreasing order, onto a stack. However, in
Algorithm 2, we only push the indices of the moveable
a[i]'s. Thus, the top element of the stack contains the
smallest index i such that a[i] is moveable. In general,
Algorithm 2 proceeds as follows. After an i is popped
from the stack, a[i] and, if necessary, a[i - 1] are
changed. These operations may cause a[i - 1] and
a[i - 2] to be moveable. The indices of the moveable
elements among a[i], a[i - 1], and a[i - 2] are then
pushed onto the stack in decreasing order. At this point,
the new combination has been generated and the stack
has been updated. We now have a nonrecursive algo-
rithm with the minimal change and loopless properties.
In the description of Algorithm 2, we assume the
existence of the standard stack operations PUSH (i),
POP (i), and the Boolean function STACKEMPTY,
which returns the value of true if the stack is empty. The
procedure C L E A R S T A C K empties the stack.
Algorithm 2. Nonrecursive generation of combinations
with minimal change and loopless properties.
(* initialization *)
CLEARSTACK;
if k mod 2 = 0 then
begin a [ k + l ] := n + 1; a[k] := k;
if k < n then P U S H (k)
end else
begin a[k] := n;
if k < n then
begin PUSH (k);
i l k > 1 then P U S H ( k - l )
end
end;
fori:= 1 tok- 1 doa[i]:=i;
PROCESS; (* first combination *)
(* main loop to generate all other combinations *)
while not S T A C K E M P T Y do
557
begin POP (i);
ifimod2=Othen
begin a [ i - l ] := a[i]; a[i] := a[O + 1;
if a[0 < a [ i + l ] - 1 then PUSH (i);
new
P U S H ( i - 1);
1 if i > 2 then P U S H (i-2)
i- 1 end else
i-- 2
begin
if i > 1 t h e n a [ i - l ] : = i - 1;
a[q := a[/'] - 1;
if a[i] > i then
begin PUSH (i);
i f / > 1 then PUSH (i-1)
end
end;
PROCESS
end (* main loop *)
The efficiency of Algorithm 2 depends on how effi-
ciently the stack operations can be implemented. Using
the method of counting operations, as in [4], Algorithm
2 is comparable in efficiency to Bitner's algorithm.
Algorithm 3 is derived from Algorithm 2 by making
changes that improve the efficiency. The major change
is to treat i = 1 and i = 2 as special cases. We shall prove
in the next theorem that these two cases occur frequently.
We define a(i) as the number of times i is popped
from the stack in Algorithm 2. Let C(r, s) be the number
of combinations or r things taken s at a time, and let
C(r,s) = 0ifr<s.
THEOREM 2.2 a ( i ) = C(n - i, k - i + 1).
PROOF. If i is odd, then o~(i) is equal to the number of
ways of choosing a[i] < . . . < a [ k ] from the set {i +
l . . . . . n}. Hence a(i) is given by Theorem 2.2. If i is
even, then a(i) is equal to the number of ways of choosing
a[i] < . . . < a [ k ] from the set {i, . . . . n} with the extra
condition that a[i] ~ a[i + 1]-1. As usual, we assume
a[ k + 1] = n + 1. Each of these choices can be generated
by choosing a[i] < . . . < a [ k ] from {i + 1. . . . . n} and
then subtracting 1 from a[i]. Hence Theorem 2.2 is also
correct when i is even. []
Every time an i is popped from the stack, a new
combination is generated. We define P(i) as the proba-
bility that a combination is generated by popping i from
the stack.
Thus
1'(i) = a ( i ) / C(n, k)
By simple algebraic manipulations, one can show that
P(1) = 1 - k / n ,
P(2) = (1 - k / n ) [ k / ( n - 1)], and
P(I) + e(2) = 1 - k ( k - l ) / [ n ( n - 1)] (1)
Equation (1) implies that the probability of popping
an i > 2 from the stack is approximately ( k / n ) 2. If k is
small compared to n, then this is a rare event. This
Communications August 1982
of Volume 25
the A C M Number 8
observation suggests that one should optimize the han- begin t[top-1] := t[top]; t[top] := top + 1
dling of the two cases, i = 1 and i = 2. In Algorithm 3, end;
whenever a 2 is popped from the stack, all the combi- top := top - 2
nations obtainable by changing only a[1] and a[2] are end else
generated in two nested loops. A side effect of this begin a[top] := a[top] - 1;
optimization step is that the portion of the algorithm if a[top] > top then
handling the cases where i > 2, does not have to test the begin top := top - 1; a[top] := top
condition i > 2 nor the condition i > 1. Hence, this end else
segment of the algorithm becomes simpler. One should begin a [ t o p - 1 ] := top - 1; i := top;
note also that 2 is now the smallest i that can be pushed top := t[top]; t[i] := i + 1
onto the stack. However, we must now treat k = 1 as a end
special case. end;
The next improvement is to make the stack opera- PROCESS
tions more efficient. On the C D C Cyber 172/2, stack end
operations are not basic instructions. We found through
The remaining case k = 1, can be handled easily with a
timing tests that it is most efficient to implement the
single loop and the code for it is not shown.
stack in a manner similar to Bitner et al. [1]. The vector
t[2.. k] is used to implement the stack. The convention
is that if i is in the stack, then t[i] gives the next element
3. Concluding Remarks
down in the stack. I f i is not in the stack, then t[i] is i +
1. The variable top contains the top element of the stack.
We shall give some empirical and theoretical com-
The bottom of the stack is denoted by 0. To avoid
parisons between Bitner's algorithm and Algorithm 3.
popping and then pushing the same element, the element
Algorithm 3 was coded with the remainder tests mod 2
top is popped from the stack only if a[top] = stop(top).
replaced by indexing into a precomputed Boolean array.
The pushing of one or more successive elements onto the
Bitner's algorithm was coded in Pascal. After verifying
stack is performed by one assignment statement.
its correctness, we did timing comparisons. Some sample
Algorithm 3. Optimized version of Algorithm 2 for results are shown in Table II. The unit of time is a
k>l. second. The timing statistics do not include the time
spent in calling the procedure PROCESS. In the table,
top := 0; (* clear the stack *)
the notation T+ corresponds to the Pascal compiler's
if k rood 2 = 0 then
option that includes runtime tests and T - corresponds
begin a [ k + l ] := n + 1; a[k] := k;
to no runtime tests. Also, timing can fluctuate by as
i l k < n then top := k
m u c h as l0 percent on our C D C Cyber 172/2 computer.
end else
As used by Ives in [4], we can also compare the two
begin a[k] := n;
algorithms by counting the n u m b e r of operations per-
ifk<nthentop:=k- 1
formed. A representative operation is the assignment
end;
operation. To generate the next combination, Bitner's
a[1] := l;
algorithm needs a m i n i m u m of 7 and a m a x i m u m of 9
t[k] := O;
assignment operations. W h e n top > 2, Algorithm 3 needs
for i : = 2 t o k - ldo
either 3 or 5 assignment operations to generate the next
begin a[i] := i; t[i] := i + 1 end;
combination. The latter case occurs if the element top is
PROCESS; (* first combination *)
to be deleted from the stack. When top = 2, Algorithm
(* main loop to generate all other combinations *)
3 takes 4 assignment operations to generate the first
while top < > 0 do
combination, and each of the remaining combinations
if top = 2 then
generated in the two nested repeat loops requires either
begin (* special handling for a[2] and a[1] *)
l or 2 assignment operations. The counts for all the other
top := t[2]; t[2] := 3;
types of operations can be obtained in a similar manner.
repeat
We now make two final observations. First of all, the
a[1] := a[2]; a[2] := a[2] + 1;
analysis of Algorithm 3 depends on how often a[top] =
PROCESS;
repeat a[1] := a[l] - 1;
Table II. Timing Comparison of Algorithm 3 and Bitner's Algorithm
PROCESS
with Time in Seconds.
until a[l] = 1
until a[2] = a[3] - 1 Algorithm 3 Bitner's Algorithm
end else n k T+ T- T+ T-
begin
if top mod 2 = 0 then 24 6 1.6 1.4 13.9 9.3
22 11 16.2 11.8 66.1 44.1
begin a [ t o p - 1 ] := a[top]; a[top] := a[top] + 1;
24 18 5.9 3.6 13.2 8.8
if a[top] = a[top+ 1] - 1 then

558 Communications August 1982

of Volume 25
the ACM Number 8
stop(top). In such a situation, the element top has to be
deleted from the stack and more operations are required
to generate the next combination. When k > top > 2,
one can show that the probability for a specific value of
top that a[top] = stop(top) is a(top + l)/a(top), which
reduces to (k - top + l ) / ( n - top). Hence, when k is
small compared to n, it is very unlikely that the next
combination is generated by using the theoretical maxi-
m u m n u m b e r of operations.
I f k is very small compared to n, then P(I), the
probability that a combination is generated by changing
only a[1], is approximately 1. In this case, almost all the
combinations are generated by the single statement a[1]
:= a[1] - 1. It is doubtful that any combination algorithm
would require less work than this to generate a combi-
nation.
Received 8/79; revised 10/81; accepted 11/81
References
1. Bitner, J.R., Ehrlich, G., and Reingold, E.M. Efficient generation
of the binary reflected Gray code and its applications. Comm. ,4 CM,
19, 9 (Sept. 1976), 517-521.
2. Ehrlich, G. Algorithm 466, Four combinatorial algorithms.
Comm. ACM, 16, II (Nov. 1973), 690-691.
3. Ehrlich, G. Loopless algorithms for generating permutations,
combinations and other combinatorial configurations. J. ,4 CM, 20,
(1973), 500-513.
4. Ives, F.M. Permutation enumeration: Four new permutation
algorithms. Comm. ACM, 19, 2 (Feb. 1976), 68-72.
5. Reingold, E.M., Nievergelt, J., and Deo, N. Combinatorial
Algorithms: Theory and Practice. Prentice-Hall, New Jersey, 1977.
559
Programming Techniques M. Douglas Mcllroy*
and Data Structures Editor
The Solution for the
Branching Factor of the
Alpha-Beta Pruning
Algorithm and its Optimality
Judea Pearl
University of California, Los Angeles
This paper analyzes N,.d, the average number of
terminal nodes examined by the a - f l pruning algorithm
in a uniform game tree of degree n and depth d for which
the terminal values are drawn at random from a contin-
uous distribution. It is shown that increasing the search
depth by one extra step would increase N,~d by a factor
(called the branching factor) ~t~_,(n) = ~,/1 - ~n ~ n 3/4
where ~,~ is the positive root of x" + x - 1 = 0. This
implies that for a given search time allotment, the a - f l
pruning allows the search depth to be increased by a
factor = 4/3 over that of an exhaustive minimax search.
Moreover, since the quantity (~n/1 - ~,~)d has been
identified as an absolute lower bound for the average
complexity of all game searching algorithms, the equality
;JC~_~(n) = ~,,/1 - ~n now renders a-fl asymptotically
optimal
C R Categories and Subject Descriptors: 1.2.8 [Artifi-
cial Intelligence]: Problem Solving, Control Methods
and Search--graph and tree search strategies, heuristic
methods; F.2.2 [Analysis of Algorithms and Problem
Complexity]: Nonnumerical Algorithms and P r o b l e m s - -
complexity of proof procedures, sorting and searching;
G.2.2 [Discrete Mathematics]: G r a p h Theory--graph
algorithms, trees
General Term: Algorithms
Additional Key Words and Phrases: alpha-beta
search, game searching, games, minimax algorithms,
branch and bound search, average case analysis
This work was supported in part by the National Science Foun-
dation Grants MCS 78-07468 and MCS 78-18924
An early versionof this paper was presented at the 8th International
Conference on Automata Languages and Algorithms, Acre, Israel, July
3-17, 1981.
* Former editor of Programming Techniques and Data Structures,
of which Ellis Horowitz is the current editor.
Author's Present Address: Judea Pearl, Cognitive Systems Labo-
ratory, Departments of Computer Science and Engineering Systems,
University of California, Los Angeles, Los Angeles, CA 90024.
Permission to copy without fee all or part of this material is
granted provided that the copies are not made or distributed for direct
commercial advantage, the ACM copyright notice and the title of the
publication and its date appear, and notice is given that copying is by
permission of the Association for Computing Machinery. To copy
otherwise, or to republish, requires a fee and/or specific permission.
© 1982 ACM 0001-0782/82/0800-0559 $00.75.
Communications August 1982
of Volume 25
the ACM Number 8