Binary Search

An old friend.
O( lg(n) )
It is truly decrease by a constant factor (⌊n/2⌋).

BINARY_SEARCH(A,start,stop,key) 

 if start > stop
    return -1
 else
    mid ← (start+stop)/2
    if A[mid] = key
       return mid
    else if A[mid] < key
       return BINARY_SEARCH(A,start,mid-1)
    else
       return BINARY_SEARCH(A,mid+1,stop)

Fake Coin Problem

I'm sure you have encountered this in games.
- You have pile of n identical coins.
- One is fake and does not weigh the same.
- You have a scale, but it is a balance scale.
- Find the fake.
For now, we will conquer the simpler problem when the fake is known to be lighter.
Brute Force
- If n is even, divide the coins into two piles.
- If n is odd, remove one coin and divide the coins into two piles.
- Compare the two piles.
- If they are equal, the fake coin is the odd coin
- Otherwise proceed recursively on the lighter pile of coins.
Why is this decrease and conquer, not divide and conquer?
Does it work?
Performance?
Can we do better? Three piles and two extra?
Give this algorithm.
What is the time?
Is this better
- Really?
- Asymptotically?

Russian Peasant Multiplication

Observe

n × m = n/2 × 2m if n is even
n × m = (n-1)/2 × 2m + m if n is odd.

This could be useful

You don't want to memorize number facts beyond two.
You are really good at shifting bits, but not at actual multiplication.
You have some really BIG numbers
You are looking for a decrease and conquer algorithm

Algorithm?

Terminate?

Work?

Performance?