Amortized Analysis

• In Prim's, and on a number of other occasions, we have done a hand wavey "but it can't be worse than this" type of analysis.
• This can be formalized with amortized analysis.
• There are a number of references
  • CLRS is good.
  • Wikipedia pages are not bad.
• This is a relatively new method (1985)
• There are three techniques presented.
  • Aggregate Analysis
  • Accounting Method
  • Potential Method
• In general the idea is we have an operation that we do many times.
  • Sometimes it is expensive.
  • Sometimes it is not.
  • We come up with the "average" expense.
• Two Problems.
  • A binary counter.
    • If we work in terms of bits, a counter is somewhat difficult.
    • We will assume a 4 bit counter and expand.
    • Each time we increment the counter, we need to change a number o9f bits.
    • Assume that there is a cost associated with flipping a bit.

      Value   Bits Flipped
      0000        
      0001         1
      0010         2
      0011         1 
      0100         3
      0101         1
      0110         2
      0111         1
      1000         4
      1001         1
      	     

    • A quick analysis says that an increment is O(n), where n is the number of bits.
    • But is this fair?
  • A stack with multipop.
    • Normal operations on a stack.
    • But the addition of MULTIPOP(S,k), which will pop k items off of the stack.
      • If the stack contains k or more items, all will be popped.
      • If it contains less than k items, the stack will be empty.
    • On first look, again, this operation will be O(k), which in the end is O(n) worst case for n, the number of items on the stack = k.
  • Aggregate Analysis
    • Consider the entire sequence of operations.
    • For binary counter add all of the bit flips
      • Σ_i=0^k-1 ⌊n/2ⁱ ⌋
      • = 2n
      • So in general, for n operations each one is constant time.
    • For multipop
      • Don't just consider the MultiPop and Pop operations
      • We must also consider the Push operations.
      • WHY?
      • When we consider all three operations the cost of an individual operation becomes O(1)
  • Accounting Method
    • In this method, we assign a charge to each operation.
    • In the end, we need the total charges to balance.
    • In the binary counter
      • The cost to change from a 0 to a 1 is 2
      • The cost to change from a 1 to a 0 is 0
      • In some sense, we Pay to flip a bit back when we flip the bit.

      • Counter    Cost
        0000
        0001        2 (20 bit)
        0010        2 (21 bit, the 20 bit was already paid for)
        0011        2 (20 bit)
        0100        2 (22 bit, the 21 and 20 bits were already paid for)
        		  

      • If we add up all of the costs (2n) and divide by the number of operations (n), we find that the total cost per operation was 2.
    • How about for Multipop?
      • A natural assignment might be Push:1, Pop:1, Multipop:N
      • But consider Push:2, Pop:0, Multipop:0
      • What does this say?
      • What will the performance be?
      • Is this a reasonable accounting scheme?
  • Consider a dynamic array
    • An array where items can be inserted at the end of the array.
    • Can we use the ideas of amortized analysis to design an efficient dynamic array?