• He classifies Binary Search as a decrease by a constant factor algorithm.
  • We cut the search in half each time.
  • We have studied this algorithm sufficiently
• The Fake coin problem
  • There are several variations of this problems.
  • Read the specs carefully,
    • There is one fake coin among n identical looking coins.
    • The fake is lighter than the other coins. (This varies)
    • We have a balance scale, with no numbers.
  • How can we solve this problem?
    • By brute force?
    • How about a decrease and conquer algorithm?
      • Think binary search.
    • He proposes that we could do better if we divided it three ways!
• Russian Peasant Multiplication
  • Notice

          |  m 	        n = 1
    n*m = |  n/2 * 2m       n is even
          | (n-1)/2*2m + m  n is odd
    	 

  • So 37*52

    37 * 52 = 18 * 2*52 + 52
            = 18 * 104 + 52
    	=  9 * 208 + 52 
    	=  4 * 416 + 208 + 52
    	=  4 * 416 + 260 
    	=  2 * 832 + 260
    	=  1 * 1664 + 260
    	= 1924
    	 

• Standard Questions.

Decrease by a variable size.

• Find the number in the i^th position in an array
• First or last are easy, how?
• how about second or next to last?
• How about the median?
• Consider this algorithm

• LOMUTO_PARTITION(A,l,r)
  
   p← A[l]
   s← l
   for i ← l+1 to r do
       if A[i] < p  then
             s ← s + 1
             swap(A[s],A[i])
   swap(A[i], A[s]
   return s
  
       

• Try with 7 2 5 9 3 12 6 18 4
• Think of s as the split between small and large
• Think of i as the split between partitioned and not partitioned
• At the end of any iteration

• 
       A[k] ≤ p  for l < k ≤ s
  and  A[k] > p  for s < k ≤ i
       A[k] unknown for k > i
       

• 
• Can you argue that lines 3-6 are correct (maintain this relationship)
• Can you argue that line 7 does the right thing?
• Timing of this algorithm?
  • good, bad?
  • What is the worst case?
• How does this algorithm help us solve our problem?

• QUICK_SELECT(A,l, r,k)
  
   s ← LOMUTO_PARTITION(A,0,A.size()-1)
   if s = k-1 then
         return  A[s]
   elseif s > l+k-1 then
         return  QUICK_SELECT(A,l,s-1,k)
   else
         return  QUICK_SELECT(A,s+1,r,k)
  
       

• Is this decrease and conquer? Why
• What is the best possible decrease?
• What is the worst?
• Does it work? Why
• How efficient?