Problem VS Algorithm

• What is a problem vs what is an algorithm?
  • A problem is a task which needs to be accomplished.
  • Given n items with a comparison operator, place these items in descending order.
  • An algorithm is a set of instructions which given a finite input solves the problem in a finite amount of time.
  • We will discuss how multiple algorithms can be applied to solve a single problem.
  • We will discuss the efficiency of these algorithms.
  • At times, we will discuss characteristics of the problems as well.
• The author investigates the problem of finding the greatest common devisor for two integers.
  • Given two non-negative integers, m, n, at least one not zero
  • The Greatest Common Divisor (written gcd(m,n)) , is the largest positive integer that divides both evenly.
  • gcd(a,0) = a, a ≠ 0
• You know one algorithm for finding the gcd(m,n)

  MIDDLE_SCHOOL_GCD(m,n)
  
   L1 ← PrimeFactorization(m)
   L2 ← PrimeFactorization(n)
   L3 ← FindCommonFactors(L1, L2)
   GCD ← 1
   for i ← 0 to  sizeof L3-1
       GCD ← GCD * L3[i]
   return  GCD
  
      

• A good practice is to trace the algorithm
  • 1050 = 2*3*5*5*7
  • 735 = 3*5*7*7
  • gcd(1050,735)
• We should ask three questions right now
  • Does this algorithm work?
  • How does the algorithm work?
  • Is it efficient?
• This algorithm presents some problems.
  • Steps 1,2,3 are complex
    • They are a long way from simple machine instructions.
    • And do we know how we will accomplish them in any case?
  • Steps 4, 5, 6 and 7 are acceptable.
• So we need an algorithm for Step 1 and 2.

• PrimeFactorization(n)
  
   L ← []
   tmp ← n
   for each prime p where p < sqrt(n) do
       while tmp%p = 0 do
            L.append(p)
            tmp ← tmp/p
   return L
  
  

• Same three questions
  • Does it work?
  • How does the algorithm work?
  • Is it efficient?
• Why do we only go to sqrt(n)
• How do we get the list of primes?
  • This turns out to be "hard"
  • There is no known formula to compute a generic next prime.
  • and probably won't ever be.
  • So we use an algorithm known as the sieve of Erastosthenes.

  • SIEVE(n)
    
     A ← []
     L ← []
     for i ← 2 to n do 
          A.pushback(i)
     for p ← 2 to sqrt(n) do
           if A[i] ≠ 0  then
           j ← p * p
          while j ≤ n do
              A[j] ← 0
              j ← j + p
     for i ← 2 to n do 
           if A[i] ≠ 0  then
               L.pushback(i) 
     return L
    
    	   

  • Same questions
    • Trace it for n=50
    • Does it work?
    • How does it work?
    • Is it efficient?
• So how "efficient" is the middle school method?
• Could we do better?
• He gives us two other algorithms
  • Conscutive
    • Start with min(m,n) and see if it divides both.

    • CONSECUTIVE(m,n)
      
       p ← min(m,n)
       if  m  = 0 then
           return  n
       if  n  = 0 then
           return  m
       while m%p ≠ 0 and n%p ≠ 0 do
          p ← p - 1
       return p
      
      	       

  • Euclid
    • Published in Elements
    • This is why we talk to Math people.

    • Euclid(m,n)
      
       while n ≠ 0 do
           r ← m % n
           m ← n
           n ← r
       return  m
      
      	     

    • Same questions...
      • Trace this first.
      • Do we have any real indication that it works?
      • How about efficiency?