Induction 2
Induction 2
Solution:
First, compare the smallest elements in the two lists, 2 and 1,
respectively. Because 1 is the smaller, put it at the beginning
of the merged list and remove it from the second list. At this
stage, the first list is 2, 3, 5, 6, the second is 4, and the
combined list is 1.
Finally, because the second list is empty, all elements of the first list
can be appended to
the end of the combined list in the order they occur in the first list.
This produces the ordered
list 1, 2, 3, 4, 5, 6.
Recurrence Relation:
A recurrence relation for the sequence {an} is
an equation that expresses an is terms of one
or more of the previous terms of the
sequence, namely,a0,a1,…,an-1, for all integers
n with n n0, where n0 is a nonnegative
integer.
Solution:
A sequence is called a solution of a
recurrence relation if its terms satisfy the
recurrence relation.
In other words, a recurrence relation is like
a recursively defined sequence, but without
specifying any initial values (initial
conditions).
Solution:
Idea: The number of valid strings equals the
number of valid strings ending with a 0 plus
the number of valid strings ending with a 1.
Let us assume that n 3, so that the string
contains at least 3 bits.
Let us further assume that we know the
number an-1 of valid strings of length (n – 1)
and the number an-2 of valid strings of length
(n – 2).
Then how many valid strings of length n are
there, if the string ends with a 1?
There are an-1 such strings, namely the set of
valid strings of length (n – 1) with a 1
appended to them.
Note: Whenever we append a 1 to a valid
Now we need to know: How many valid
strings of length n are there, if the string
ends with a 0?
Valid strings of length n ending with a 0 must
have a 1 as their (n – 1)st bit (otherwise they
would end with 00 and would not be valid).
And what is the number of valid strings of
length (n – 1) that end with a 1?
We already know that there are an-1 strings of
length n that end with a 1.
Therefore, there are an-2 strings of length (n –
1) that end with a 1.
So there are an-2 valid strings of length n that
end with a 0 (all valid strings of length (n – 2)
with 10 appended to them).
Solution:
The characteristic equation of the recurrence
relation is r2 – r – 2 = 0.
Its roots are r = 2 and r = -1.
Hence, the sequence {an} is a solution to the
recurrence relation if and only if:
an = 12n + 2(-1)n for some constants 1 and
2.
Given the equation an = 12n + 2(-1)n and the
initial conditions a0 = 2 and a1 = 7, it follows
that
a0 = 2 = 1 + 2
a1 = 7 = 12 + 2 (-1)
5 5
n
2 2
But what happens if the characteristic
equation has only one root?
How can we then match our equation with the
initial conditions a0 and a1 ?
Theorem:
Let c1 and c2 be real numbers with c2 0.
Suppose that r2 – c1r – c2 = 0 has only one root
r0.
A sequence {an} is a solution of the recurrence
relation an = c1an-1 + c2an-2 if and only if
an = 1r0n + 2nr0n, for n = 0, 1, 2, …, where 1
and 2 are constants.
Example: What is the solution of the recurrence
relation an = 6an-1 – 9an-2 with a0 = 1 and a1 = 6?
Solution:
The only root of r2 – 6r + 9 = 0 is r0 = 3.
Hence, the solution to the recurrence relation is
an = 13n + 2n3n for some constants 1 and 2.
To match the initial condition, we need
a0 = 1 = 1
a1 = 6 = 13 + 23
Solving these equations yields 1 = 1 and 2 = 1.
Consequently, the overall solution is given by
an = 3n + n3n.
Divide-and-Conquer Relations
Some algorithms take a problem and
successively divide it into one or more smaller
problems until there is a trivial solution to them.
For example, the binary search algorithm
recursively divides the input into two halves and
eliminates the irrelevant half until only one
relevant element remained.
This technique is called “divide and conquer”.
We can use recurrence relations to analyze the
complexity of such algorithms.
Suppose that an algorithm divides a problem
(input) of size n into a subproblems, where
each subproblem is of size n/b. Assume that
g(n) operations are performed for such a
division of a problem.
Then, if f(n) represents the number of
operations required to solve the problem, it
follows that f satisfies the recurrence relation
f(n) = af(n/b) + g(n).
This is called a divide-and-conquer
recurrence relation.
Example: The binary search algorithm reduces
the search for an element in a search sequence
of size n to the binary search for this element
in a search sequence of size n/2 (if n is even).
Two comparisons are needed to perform this
reduction.
Hence, if f(n) is the number of comparisons
required to search for an element in a search
sequence of size n, then
f(n) = f(n/2) + 2 if n is even.
Usually, we do not try to solve such divide-and
conquer relations, but we use them to derive a
big-O estimate for the complexity of an algorithm.
Theorem:
Let f be an increasing function that satisfies the
recurrence relation
f(n) = af(n/b) + cnd
whenever n = bk, where k is a positive integer, a,
c, and d are real numbers with a 1, and b is an
integer greater than 1. Then f(n) is
O(nd), if a < bd,
O(nd log n) if a = bd,
O(nlogba) if a > bd
Example:
For binary search, we have
f(n) = f(n/2) + 2, so a = 1, b = 2, and d = 0
(d = 0 because here, g(n) does not depend on
n).
Consequently, a = bd, and therefore,
f(n) is O(nd log n) = O(log n).
The binary search algorithm has logarithmic
time complexity.