编程之美之一摞烙饼的问题

我对编程之美中一摞烙饼的问题中的算法用Python实现了一遍，并且进行了优化，直接上代码吧：

#!/usr/bin/env python

class PrefixSorting(object):
    def __init__(self, ):
        self._cakes = []
        self._reverseCakes = []
        self._maxSwap = 0
        self._swaps = []
        self._reverseSwap = []
        self._search = 0
    
    def run(self, cakes):
        self.init(cakes)
        self._search = 0;
        self.search(0)
    
    def outPut(self):
        print self._swaps
        print self._search
        print self._maxSwap
    
    def init(self, cakes):
        self._cakes = cakes[:]
        self._reverseCakes = cakes[:]
        self._maxSwap = self.upperBound(len(cakes))
        self._swaps = [0]*self._maxSwap
        self._reverseSwap = [0]*self._maxSwap
        self._search = 0
    
    def upperBound(self, cakeCount):
        return cakeCount*2
    
    def lowerBound(self, cakes):
        result = 0
        for i in range(len(cakes)-1):
            t = cakes[i+1] - cakes[i]
            if t > 1 or t < -1:
                result = result+1
        return result
    
    def search(self, step):
        self._search = self._search + 1
        estimate = self.lowerBound(self._reverseCakes)
        if step + estimate >= self._maxSwap:
            return
        reverseCakes = self._reverseCakes[:]
        reverseCakes.sort()
        if reverseCakes == self._reverseCakes:
            if step < self._maxSwap:
                self._cakes = self._reverseCakes[:]
                self._maxSwap = step
                self._swaps = self._reverseSwap[:self._maxSwap]
                self._swaps = self.normal(self._swaps[:])
                self._maxSwap = len(self._swaps)
            return
        for i in range(len(self._cakes)-1):
            self.reverse(i+1)
            self._reverseSwap[step] = i+1
            if step < len(self._reverseSwap) - 1:
                self._reverseSwap[step+1:] = [0]*(len(self._reverseSwap)-step-1)
            self.search(step+1)
            self.reverse(i+1)
            
    def reverse(self, i):
        if i < len(self._reverseCakes)-1:
            header = self._reverseCakes[0:i+1]
            header.reverse()
            self._reverseCakes = header+self._reverseCakes[i+1:]
        else:
            self._reverseCakes.reverse()
            
    def normal(self, swap):
        i = 0
        while i < len(swap)-1:
            if swap[i] == swap[i+1]:
                swap[i:i+2]=[]
                i = i-1 if i > 0 else 0
            else:
                i = i+1
        return swap
    
            
if __name__ == '__main__':
    pS = PrefixSorting()
    pS.run([3,2,1,6,5,4,9,8,7,0])
    pS.outPut()

normal函数就是优化的地方。