0% found this document useful (0 votes)

44 views

CS 473: Algorithms: Chandra Chekuri Chekuri@cs - Illinois.edu 3228 Siebel Center

This document describes an algorithm class called recursion. It provides the Tower of Hanoi puzzle as an example of a recursively solved problem. The solution moves the disks on three pegs, one at a time, according to the rule that no larger disk can be placed on top of a smaller one. It recursively reduces the problem of moving n disks to the problem of moving n-1 disks, plus moving the largest disk. The number of moves required to solve the Tower of Hanoi puzzle for n disks is 2^n - 1.

Uploaded by

Nguyễn Quang Huy

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

44 views

CS 473: Algorithms: Chandra Chekuri Chekuri@cs - Illinois.edu 3228 Siebel Center

Uploaded by

Nguyễn Quang Huy

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 98

CS 473: Algorithms

Chandra Chekuri
chekuri@cs.illinois.edu
3228 Siebel Center
University of Illinois, Urbana-Champaign

Fall 2010

Chekuri CS473 1
Reductions
Recursion

Part I

Reductions and Recursion

Chekuri CS473 2
Reductions
Recursion

Reduction

Reducing problem A to problem B:

Algorithm for A uses algorithm for B as a black box

Chekuri CS473 3
Reductions
Recursion

Distinct Elements Problem

Problem Given an array A of n integers, are there any

duplicates in A?

Chekuri CS473 4
Reductions
Recursion

Distinct Elements Problem

Problem Given an array A of n integers, are there any

duplicates in A?

Naive algorithm:
for i = 1 to n − 1 do
for j = i + 1 to n do
if (A[i] = A[j])
return YES
endfor
endfor
return NO

Chekuri CS473 4
Reductions
Recursion

Distinct Elements Problem

Problem Given an array A of n integers, are there any

duplicates in A?

Naive algorithm:
for i = 1 to n − 1 do
for j = i + 1 to n do
if (A[i] = A[j])
return YES
endfor
endfor
return NO

Running time:

Chekuri CS473 4
Reductions
Recursion

Distinct Elements Problem

Problem Given an array A of n integers, are there any

duplicates in A?

Naive algorithm:
for i = 1 to n − 1 do
for j = i + 1 to n do
if (A[i] = A[j])
return YES
endfor
endfor
return NO

Running time: O(n2 )

Chekuri CS473 4
Reductions
Recursion

Reduction to Sorting

Sort A
for i = 1 to n − 1 do
if (A[i] = A[i + 1]) then
return YES
endfor
return NO

Chekuri CS473 5
Reductions
Recursion

Reduction to Sorting

Sort A
for i = 1 to n − 1 do
if (A[i] = A[i + 1]) then
return YES
endfor
return NO

Running time: O(n) plus time to sort an array of n numbers

Important point: algorithm uses sorting as a black box

Chekuri CS473 5
Reductions
Recursion

Two sides of Reductions

Suppose problem A reduces to problem B

Positive direction: Algorithm for B implies an algorithm for A
Negative direction: Suppose there is no “efficient” algorithm
for A then it implies no efficient algorithm for B (technical
condition for reduction time necessary for this)

Chekuri CS473 6
Reductions
Recursion

Two sides of Reductions

Suppose problem A reduces to problem B

Example: Distinct Elements reduces to Sorting in O(n) time

An O(n log n) time algorithm for Sorting implies an O(n log n)
time algorithm for Distinct Elements problem.
If there is no o(n log n) time algorithm for Distinct Elements
problem then there is no o(n log n) time algorithm for Sorting.

Chekuri CS473 6
Reductions
Recursion

Recursion

Reduction: reduce one problem to another

Recursion: a special case of reduction

reduce problem to a smaller instance of itself
self-reduction

Chekuri CS473 7
Reductions
Recursion

Recursion

Reduction: reduce one problem to another

Recursion: a special case of reduction

reduce problem to a smaller instance of itself
self-reduction

Problem instance of size n is reduced to one or more instances

of size n − 1 or less.
For termination, problem instances of small size are solved by
some other method as base cases

Chekuri CS473 7
Reductions
Recursion

Recursion

Recursion is a very powerful and fundamental technique

Basis for several other methods
Divide and conquer
Dynamic programming
Enumeration and branch and bound etc
Some classes of greedy algorithms
Makes proof of correctness easy (via induction)
Recurrences arise in analysis

Chekuri CS473 8
Reductions
Recursion

Selection Sort

Sort a given array A[1..n] of integers.

Recursive version of Selection sort.

SelectSort(A[1..n]):
If (n = 1) return
Find smallest number in A. Let A[i] be smallest number
Swap A[1] and A[i]
SelectSort(A[2..n])

Chekuri CS473 9
Reductions
Recursion

Selection Sort

Sort a given array A[1..n] of integers.

Recursive version of Selection sort.

SelectSort(A[1..n]):
If (n = 1) return
Find smallest number in A. Let A[i] be smallest number
Swap A[1] and A[i]
SelectSort(A[2..n])

T (n): time for SelectionSort on an n element array.

T (n) = T (n − 1) + n for n > 1 and T (1) = 1 for n = 1

T (n) =

Chekuri CS473 9
Reductions
Recursion

Selection Sort

Sort a given array A[1..n] of integers.

Recursive version of Selection sort.

SelectSort(A[1..n]):
If (n = 1) return
Find smallest number in A. Let A[i] be smallest number
Swap A[1] and A[i]
SelectSort(A[2..n])

T (n): time for SelectionSort on an n element array.

T (n) = T (n − 1) + n for n > 1 and T (1) = 1 for n = 1

T (n) = Θ(n2 ).

Chekuri CS473 9
one of the other needles, tower, temple, and Brahmins alike will crumble into dust, and with a
Reductions
thunderclap the world will vanish. Recursion

Of course, being good computer scientists, we read this story and immediately substitute n for the
Tower of Hanoi
hardwired constant sixty-four.4 How can we move a tower of n disks from one needle to another,
using a third needles as an occasional placeholder, never placing any disk on top of a smaller disk?

The Tower of Hanoi puzzle

The trick to solving this puzzle is to think recursively. Instead of trying to solve the entire puzzle
all at once, let’s concentrate on moving just the largest disk. We can’t move it at the beginning,
Move stack of n disks from peg 0 to peg 2, one disk at a time.
because all the other disks are covering it; we have to move those n − 1 disks to the third needle
before Rule:
we can cannot
move theput a larger
nth disk. disk after
And then on awesmaller
move the disk.
nth disk, we have to move those
n − 1 disks back on top of it. So now all we have to
Question: what is a strategy and how many moves figure out is how to. .does
. it take?
3
This English translation is from W. W. Rouse Ball and H. S. M.
Chekuri Coxeter’s book Mathematical Recreations and Essays.
CS473 10
Reductions
Recursion

Tower of Hanoi via Recursion

Algorithms Lecture 1: Recursion

STOP!! That’s it! We’re done! We’ve successfully reduced the n-disk Tower of Hanoi problem to
two instances of the (n − 1)-disk Tower of Hanoi problem, which we can gleefully hand off to the
Recursion Fairy (or, to carry the original story further, to the junior monks at the temple).

recursion

The Tower of Hanoi algorithm; ignore everything but the bottom disk

Our algorithm does make one subtle but important assumption: there is a largest disk. In other
words, our recursive algorithm works for any n ≥ 1, but it breaks down when n = 0. We must
handle that base case directly. Fortunately, the monks at Benares, being good Buddhists, are quite
adept at moving zero disks from one needle to another.

Chekuri CS473 11
Reductions
Recursion

Recursive Algorithm

Hanoi(n, src, dest, tmp):

If (n > 0) do
Hanoi(n − 1, src, tmp, dest)
Move disk n from src to dest
Hanoi(n − 1, tmp, dest, src)

Chekuri CS473 12
Reductions
Recursion

Recursive Algorithm

Hanoi(n, src, dest, tmp):

If (n > 0) do
Hanoi(n − 1, src, tmp, dest)
Move disk n from src to dest
Hanoi(n − 1, tmp, dest, src)

T (n): time to move n disks via recursive strategy

Chekuri CS473 12
Reductions
Recursion

Recursive Algorithm

Hanoi(n, src, dest, tmp):

If (n > 0) do
Hanoi(n − 1, src, tmp, dest)
Move disk n from src to dest
Hanoi(n − 1, tmp, dest, src)

T (n): time to move n disks via recursive strategy

T (n) = 2T (n − 1) + 1 n>1 and T (1) = 1

Chekuri CS473 12
Reductions
Recursion

Analysis

T (n) = 2T (n − 1) + 1
= 22 T (n − 2) + 2 + 1
= ...
= 2i T (n − i) + 2i−1 + 2i−2 + . . . + 1
= ...
= 2n−1 T (1) + 2n−2 + . . . + 1
= 2n−1 + 2n−2 + . . . + 1
= (2n − 1)/(2 − 1) = 2n − 1

Chekuri CS473 13
Reductions
Recursion

Non-Recursive Algorithms for Tower of Hanoi

Pegs numbered 0, 1, 2

Non-recursive Algorithm 1:
Always move smallest disk forward if n is even, backward if n
is odd.
Never move the same disk twice in a row.
Done when no legal move.

Chekuri CS473 14
Reductions
Recursion

Non-Recursive Algorithms for Tower of Hanoi

Pegs numbered 0, 1, 2

Non-recursive Algorithm 1:
Always move smallest disk forward if n is even, backward if n
is odd.
Never move the same disk twice in a row.
Done when no legal move.
Non-recursive Algorithm 2:
Let ρ(n) be the smallest integer k such that n/2k is not an
integer. Example: ρ(40) = 4, ρ(18) = 2.
In step i move disk ρ(i) forward if n − i is even and backward
if n − i is odd.

Chekuri CS473 14
Reductions
Recursion

Non-Recursive Algorithms for Tower of Hanoi

Pegs numbered 0, 1, 2

Part II