def p107(network="p107.network"):
network=open(network)
network=[row.split(',') for row in network.read().split('\n')[:-1]]
edges=Heap(0)
counter=0
for i in xrange(len(network)):
if network[0][i]!='-':
edges.add((int(network[0][i]),0,i))
vertices=set([0])
cost=0
total_cost=0
for i in xrange(len(network)):
for j in xrange(i+1,len(network)):
if network[i][j]!='-':
total_cost+=int(network[i][j])
while len(vertices)<len(network):
edge=edges.removeMin()
while edge[2] in vertices:
edge=edges.removeMin()
vertices.add(edge[2])
cost+=edge[0]
for i in xrange(len(network)):
if network[edge[2]][i]!='-':
edges.add((int(network[edge[2]][i]),edge[2],i))
print total_cost-cost
def setUp(self):
heap = Heap(3, 1)
heap.add(2)
heap.add(3)
heap.add(4)
heap.add(5)
self.heap = heap
def p107(network="p107.network"):
network = open(network)
network = [row.split(',') for row in network.read().split('\n')[:-1]]
edges = Heap(0)
counter = 0
for i in xrange(len(network)):
if network[0][i] != '-':
edges.add((int(network[0][i]), 0, i))
vertices = set([0])
cost = 0
total_cost = 0
for i in xrange(len(network)):
for j in xrange(i + 1, len(network)):
if network[i][j] != '-':
total_cost += int(network[i][j])
while len(vertices) < len(network):
edge = edges.removeMin()
while edge[2] in vertices:
edge = edges.removeMin()
vertices.add(edge[2])
cost += edge[0]
for i in xrange(len(network)):
if network[edge[2]][i] != '-':
edges.add((int(network[edge[2]][i]), edge[2], i))
print total_cost - cost
def heap_sort(lst):
a_heap = Heap()
for item in lst:
a_heap.add(item)
tmp = []
while not a_heap.is_empty():
tmp.append(a_heap.get_max())
return tmp
class WeightBasedExpReplay(object):
def __init__(self, maxSize, alpha=0.6, epsilon=0.000001):
self.maxSize = maxSize
self.buffer = Buffer(self.maxSize)
self.sumTree = SumTree(self.maxSize)
self.weights = {}
self.alpha = 0.6
self.curSize = 0
self.epsilon = epsilon
self.heap = Heap()
def addExperience(self, experience):
weight = self.heap.getMaxPriority()
index = self.buffer.getPointer()
self.buffer.insert(experience)
prevWeight = 0
if index in self.weights:
prevWeight = self.weights[index]
diffWeight = weight - prevWeight
self.weights[index] = weight
self.sumTree.insert(diffWeight, index)
self.heap.add(index, weight)
self.curSize = min(self.curSize + 1, self.maxSize)
def modifyExperience(self, weight, index):
weight = weight + self.epsilon
weight = weight**self.alpha
prevWeight = 0
if index in self.weights:
prevWeight = self.weights[index]
diffWeight = weight - prevWeight
self.weights[index] = weight
self.sumTree.insert(diffWeight, index)
self.heap.add(index, weight)
def sample(self, samplesAmount):
startPoints = np.linspace(0, self.sumTree.getAllSum(),
samplesAmount + 1).tolist()
expList = []
weightList = []
indexList = []
for a in range(len(startPoints) - 1):
start = startPoints[a]
end = startPoints[a + 1]
sampledNum = np.random.uniform(start, end)
retrIndex = self.sumTree.search(sampledNum)
expList.append(self.buffer.getItem(retrIndex))
weightList.append(self.weights[retrIndex] /
self.sumTree.getAllSum())
indexList.append(retrIndex)
return np.asarray(expList), np.asarray(weightList), np.asarray(
indexList)
def getMaxPriority(self):
if self.heap.size == 0:
return sys.float_info.max
return self.heap.p2w[1]
def heapSort(list):
heap = Heap() # Create a Heap
# Add elements to the heap
for v in list:
heap.add(v)
# Remove elements from the heap
for i in range(len(list)):
list[len(list) - 1 - i] = heap.remove()
def heapSort(list):
heap = Heap() # Create a Heap
# Add elements to the heap
for v in list:
heap.add(v)
# Remove elements from the heap
for i in range(len(list)):
list[len(list) - 1 - i] = heap.remove()
def getHuffmanTree(counts):
# Create a heap to hold trees
heap = Heap() # Defined in Listing 11.8
for i in range(len(counts)):
if counts[i] > 0:
heap.add(Tree(Node(counts[i], chr(i)))) # A leaf node tree
while heap.getSize() > 1:
t1 = heap.remove() # Remove the smallest-weight tree
t2 = heap.remove() # Remove the next smallest
heap.add(Tree(t1, t2)) # Combine two trees
return heap.remove() # The final tree
def getHuffmanTree(counts):
# Create a heap to hold trees
heap = Heap() # Defined in Listing 11.8
for i in range(len(counts)):
if counts[i] > 0:
heap.add(Tree(Node(counts[i], chr(i)))) # A leaf node tree
while heap.getSize() > 1:
t1 = heap.remove() # Remove the smallest-weight tree
t2 = heap.remove() # Remove the next smallest
heap.add(Tree(t1, t2)) # Combine two trees
return heap.remove() # The final tree
def _heap_tree(self, *args):
if len(args) == 0:
heap = Heap()
node = self.Root
else:
node = args[0]
heap = args[1]
if node.left:
self._heap_tree(node.left, heap)
heap.add(node)
if node.right:
self._heap_tree(node.right, heap)
return heap
class PriorityQueue:
def __init__(self):
self.__heap = Heap()
# Adds an element to this queue
def enqueue(self, e):
self.__heap.add(e)
# Removes an element from this queue
def dequeue(self):
if self.getSize() == 0:
return None
else:
return self.__heap.remove()
# Return the size of the queue
def getSize(self):
return self.__heap.getSize()
class Spanning:
"create the miminal spanning tree"
def __init__(self, root,ln):
self.__root = root
self.__seen = []
self.__links = Heap()
self.__shorts = []
self.__length = ln
def walk(self,to=None):
if to is None:
self.__walkToEnd()
else:
self.__walkTo(to)
def __walkToEnd(self):
while len(self.__seen) < self.__length:
self.__root.setVisit()
self.__seen.append(self.__root)
print(self.tree())
self.__findLinks(self.__root)
if len(self.__seen) == self.__length:
break
less = self.getnext()
self.__shorts.append(less)
self.__root = less.toNode()
def __walkTo(self, to):
while self.__root.getName() != to:
self.__root.setVisit()
self.__seen.append(self.__root)
print(self.tree())
self.__findLinks(self.__root)
if self.__root.getName() == to:
break
less = self.getnext()
self.__shorts.append(less)
self.__root = less.toNode()
def getnext(self):
less = less = self.__links.mini()
while less.toNode().visited():
less = less = self.__links.mini()
less.toNode().setFrom(less.getFrom())
less.toNode().setCost(less.getFrom().getCost()+less.getWeight())
return less
def __findLinks(self, node):
print(node,"finding")
for link in node.links():
if not link.toNode().visited():
self.__links.add(link)
def tree(self):
return [i.getName() for i in self.__seen]
def result(self):
print( [(i.getFrom().getName(), i.toNode().getName(),i.getWeight()) \
for i in self.__shorts])
def path(self):
result = ""
node = self.__shorts[-1].toNode()
cost =node.getCost()
print(node.fromNode())
while node.fromNode() is not None:
result = "-->"+node.getName() + result
node = node.fromNode()
return node.getName() + result +" = " + str(cost)
def dd(self):
for node in self.__seen:
print(node.fromNode())
class RankBasedExpReplay(object):
def __init__(self,maxSize, alpha=0.6):
self.maxSize = maxSize
self.buffer = Buffer(self.maxSize)
self.heap = Heap()
self.weights = None
#Add two flags to indicate whether alpha or queue size has changed
self.prevAlpha = alpha
self.prevSize =0
# Variables to store current alpha and exp replay size
self.alpha = alpha
self.curSize = 0
#Weightings to each experience
self.endPoints = []
def addExperience(self, experience):
index = self.buffer.getPointer()
self.buffer.insert(experience)
weight = self.heap.getMaxPriority()
self.heap.add(index, weight)
self.curSize = self.heap.size
def modifyExperience(self, weight, index):
self.heap.add(index, weight)
self.curSize = self.heap.size
def sample(self, samplesAmount):
if (self.prevAlpha != self.alpha) or (self.prevSize != self.curSize) :
self.endPoints, self.weights = self.computeBoundaries(self.alpha, self.curSize, samplesAmount)
self.prevAlpha = self.alpha
self.prevSize = self.curSize
totalWeights = sum(self.weights)
startPoint = 0
expList = []
weightList = []
indexList = []
for a in self.endPoints :
end = a + 1
diff = end - startPoint
sampledNum = np.random.randint(diff, size=1)[0]
retrIndex = startPoint + sampledNum
startPoint = end
expList.append(self.buffer.getItem(self.heap.getIndex(retrIndex)))
weightList.append(self.weights[retrIndex]/totalWeights)
indexList.append(retrIndex)
return np.asarray(expList),np.asarray(weightList),np.asarray(indexList)
def computeBoundaries(self, alpha, curSize, samplesAmount):
ranks = list(range(curSize))
weights = [(1.0/(rank+1))**alpha for rank in ranks]
sumAllWeights = sum(weights)
stops = np.linspace(0,sumAllWeights,samplesAmount+1).tolist()
del stops[0]
curSum = 0
curFounded = 0
curStop = -1
results = []
for a in weights:
curSum += a
curStop += 1
if curSum >= stops[curFounded]:
results.append(curStop)
curFounded += 1
return results, weights
def rebalance(self):
indexList = []
weightList = []
while self.heap.size != 0:
maxIndex = self.heap.p2i[1]
maxWeight = self.heap.p2w[1]
indexList.append(maxIndex)
weightList.append(maxWeight)
self.heap.delete(maxIndex)
for a in range(len(indexList)):
self.add(indexList[a],weightList[a])
def getMaxPriority(self):
if self.heap.size == 0:
return sys.float_info.max
return self.heap.p2w[1]
avl_read.get_node(1).hotnessCount = 1
avl_read.get_node(3).hotnessCount = 277
"""
n1.hotnessCount = 7
n2.hotnessCount = 9
n3.hotnessCount = 688
n4.hotnessCount = 1
n5.hotnessCount = 277
"""
heap.add(avl_read.get_node(143))
heap.add(avl_read.get_node(18))
heap.add(avl_read.get_node(1432))
heap.add(avl_read.get_node(1))
heap.add(avl_read.get_node(3))
"""
heap.add(n1)
heap.add(n2)
heap.add(n3)
heap.add(n4)
heap.add(n5)
heap.heapsort()
lis = heap.showArray()
for l in lis:
print "key = ", l.key, " count = ",l.hotnessCount
#print heap.pop().key
#print heap.pop().key
#print heap.pop().key
#print heap.pop().key
#print heap.pop().key
from Heap import Heap
x=Heap()
for i in xrange(20,0,-1):
x.add(i)
x.getSelf()
from Heap import Heap H = Heap() H.add(10) H.add(15) H.add(17) H.add(20) H.add(8) H.add(9) print(H.peek() == 8) H.poll() print(H.peek() == 9) H.poll() print(H.peek() == 10) H.poll() print(H.peek() == 15)
