def addSpot(self, floor, spot): #create spot by inserting in heap if floor > self.maxFloors or spot > self.spotsPerFloor: print("Value out of bounds") else: newSpot = ParkingSpot(floor, spot) insert(self.heap, newSpot)
def nthUglyNumber(self, n: int) -> int: # edge case check if (n == 1): return n # initializations minHeap = [1] visited = set([1]) count = 0 primes = [2, 3, 5] poppedElement = 1 # iterate until nth ugly number while (count < n): # remove min element from min heap poppedElement = remove(minHeap) count += 1 # for each of the primes, mutlipy min element and push into heap if not in the hash set for prime in primes: nextElement = poppedElement * prime if (nextElement not in visited): visited.add(nextElement) insert(minHeap, nextElement) # return the nth popped element from min heap return poppedElement
def run(self): user_priority_q = [] post_q = [] for i in range(self.number_of_users): username = get_random_string(16) user_bot = UserBot(username=username, password='******', email=username+'@close.io') insert(user_priority_q, (i, user_bot.number_of_posts, user_bot)) post_q.append(user_bot.posts) while user_priority_q and post_q: user_bot = extract_maximum(user_priority_q)[-1] user_finished = False while user_priority_q and not user_finished and post_q and user_bot.number_of_likes: posts = post_q.pop() if not user_bot.posts.intersection(posts): for _ in range(min([user_bot.number_of_likes, len(posts)])): user_bot.make_like(posts.pop()) if not post_q: user_finished = True if posts: post_q.append(posts)
def a_star(state): """ algorithm A* """ ideal = '123456789ABCDEF0' if not have_a_solve(state): print('No solution!') return [] h = get_heuristic(state) g = 0 node = Node(f=get_f(g, h), value=state, parent=None, g=g, h=h) pq = [] # priority queue insert(pq, node) res = list() # list of result way close = set() while pq: cur = extract(pq) # extract last node if cur.value == ideal: print('Success!') g = cur.g res.append(cur.value) while cur.parent: res.append(cur.parent.value) cur = cur.parent res.reverse() return res, g if cur.value not in close: close.add(cur.value) # add 4 ways to queue ways = [up(cur.value), right(cur.value), down(cur.value), left(cur.value)] for way in ways: if way: h = get_heuristic(way) g = cur.g + 1 node = Node(f=get_f(g, h), value=way, parent=cur, g=g, h=h) insert(pq, node)
def lastStoneWeight(self, stones: List[int]) -> int: # Time: O(NlogN + N/2logN) ~ O(NlogN) # Space: O(N) for maxHeap # initializations maxHeap = [] # filling maxHeap with -1 times the actual value for i in range(len(stones)): insert(maxHeap, -stones[i]) # remove last 2 elements (as numbers are negative an we have only minHeap in py) while (len(maxHeap) > 1): first = remove(maxHeap) second = remove(maxHeap) # if equal => don't do anything and continue the loop if (first == second): continue # otherwise insert -1 times the absolute value of top 2 numbers insert(maxHeap, -1 * abs(first - second)) # if one element present => take out the absolute value # else return 0 if (len(maxHeap) == 1): return (-1 * remove(maxHeap)) else: return 0
def addParkingSpace(self, floor: int, slot: int) -> None: parkingSpace = ParkingSpace(floor, slot) # if parking space is in limitations => add it to the available slots in priority queue if (floor < self.__maxFloors and slot < self.__maxSlots): insert(self.__priorityQueue, parkingSpace) # else do nothing else: print('Try another Floor and another Slot !!!')
def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]: heap = [] result = [] for p in points: dist = -(p[0]**2 + p[1]**2) insert(heap, [dist, p]) if len(heap) > K: remove(heap) for i in heap: result.append(i[1]) return result
def __init__(self, k: int, nums: List[int]): # initialize in such a way that your Data Structure has only k largest elements self.minHeap = [] self.capacity = k for num in nums: insert(self.minHeap, num) if (len(self.minHeap) > k): remove(self.minHeap)
def main(): string = input() dictionary = {} # считываем символы и их частоты for ch in string: if ch in dictionary.keys(): dictionary[ch] += 1 else: dictionary[ch] = 1 # добавляем символы в очередь, используя частоту в качестве приоритета pq = [] ident = 0 for ch in dictionary: priority = dictionary.get(ch) insert(pq, (priority, ident, ch)) ident += 1 dictionary[ch] = '' if len(pq) == 1: dictionary[pq[0][2]] = '0' else: # создаем узлы дерева while len(pq) > 1: min1 = extract_min(pq) min2 = extract_min(pq) if type(min1[2]) is str: leaf1 = Tree(min1[2], min1[0]) else: leaf1 = min1[2] if type(min2[2]) is str: leaf2 = Tree(min2[2], min2[0]) else: leaf2 = min2[2] F = Tree(None, leaf1.freq + leaf2.freq, right=leaf2, left=leaf1) insert(pq, (F.freq, ident, F)) ident += 1 F.freq = None creating_code(dictionary, F) encoded_string = '' for ch in string: encoded_string += dictionary[ch] print(f'{len(dictionary)} {len(encoded_string)}') for i in dictionary: print(f'{i}: {dictionary[i]}') print(encoded_string)
def leastInterval(self, tasks: List[str], n: int) -> int: # initializations frequencyMap = {} T = len(tasks) maxHeap = [] time = 0 # fill frequency map for task in tasks: if task in frequencyMap: frequencyMap[task] += 1 else: frequencyMap[task] = 1 # insert all frequency map info into the Heap for char in frequencyMap: charFreq = FrequencyMap(char, frequencyMap[char]) insert(maxHeap, charFreq) # iterate until nothing is left in Heap while (len(maxHeap) > 0): # to calculate cooldown time tempTime = 0 bufferList = [] # iterate cooldown time ends while (tempTime <= n): # If any element in Heap if (len(maxHeap) > 0): maxCharFreq = maxHeap[0] if (maxCharFreq.freq > 1): # if frequency > 1 maxCharFreq.freq -= 1 bufferList.append(maxCharFreq) # add to buffer list remove(maxHeap) # remove max element anyway time += 1 # increment overall time # if nothing exists in both Heap and buffer list => we're done if (len(maxHeap) == 0 and len(bufferList) == 0): break # increment twmp time until <= cooldown time tempTime += 1 # now after cooldown, add each entry from Buffer list to Max Heap for eachEntry in bufferList: insert(maxHeap, eachEntry) # return overall time return time
def getValues(self, countMap): heap = [] for key in countMap: count = countMap[key] p = Pair(key, count) insert(heap, p) if len(heap) > 3: remove(heap) stack = [] while len(heap) > 0: stack.append(remove(heap).sentence) return stack[::-1]
def minMeetingRooms(self, intervals): if not intervals: return 0 heap = [] intervals = sorted(intervals, key=lambda interval: interval.start) for i in intervals: if len(heap) == 0: insert(heap, i.end) continue if i.start >= heap[0]: remove(heap) insert(heap, i.end) return len(heap)
def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]: minHeap = [] # once the size overloads => remove the max element from the heap for point in points: newPoint = Point(point) insert(minHeap, newPoint) if (len(minHeap) > K): remove(minHeap) return [each.point for each in minHeap]
def add(self, val: int) -> int: # first insert the new value and if size exceeds => remove the min value insert(self.minHeap, val) if (len(self.minHeap) > self.capacity): remove(self.minHeap) # kth largest would be == first element return self.minHeap[0] # Your KthLargest object will be instantiated and called as such: # obj = KthLargest(k, nums) # param_1 = obj.add(val)
def main(): k, l = map(int, input().split()) # количество различных букв в строке, размер получившейся закодированной строки _dict = {} for i in range(k): _str = input() _dict[_str[3:]] = _str[0] encoded_string = input() pq = [] for ch in _dict: code = [i for i in ch] insert(pq, (code, _dict[ch])) root = create_decode_tree(pq) print(decoding(encoded_string, root))
def getNewsFeed(self, userId: int) -> List[int]: """ Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. """ q = [] followers = self.UserMap[userId] followers.add(userId) for f in followers: for tweet in self.TweetsMap[f]: t, post = tweet[0], tweet[1] if len(q) < 10: insert(q, (t, post)) elif t > q[0][0]: remove(q) insert(q, (t, post)) result = [] while q: t, post = remove(q) result.append(post) return result[::-1]
def getNewsFeed(self, userId: int) -> List[int]: """ Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent. """ self._newUser(userId) tweet_list = [] followedUsers = self.user_follower[userId] if followedUsers: for followee in followedUsers: if followee in self.user_tweet and len( self.user_tweet[followee]) > 0: for tweet in self.user_tweet[followee]: insert(tweet_list, tweet) if len(tweet_list) > self.feed_limit: remove(tweet_list) output = [] while len(tweet_list) > 0: output.append(remove(tweet_list).tweetId) return output[::-1]
def calculate_dijkstra(graph: Graph, source: int) -> Dict[int, Dict[str, Any]]: result = {node: {COST: inf, ARC: None, VISITED: False} for node in graph} result[source][COST] = 0 to_visit = [] insert(to_visit, (0, source)) while len(to_visit) > 0: to_open = extract_minimum(to_visit)[1] if result[to_open][VISITED]: continue result[to_open][VISITED] = True for arc in graph[to_open][OUT_ARCS]: new_cost = result[to_open][COST] + arc.info[WEIGHT] if result[arc.dest][COST] > new_cost: result[arc.dest][COST] = new_cost result[arc.dest][ARC] = arc.index insert(to_visit, (new_cost, arc.index)) return result
def __getTopK(self, frequencyMap): # initialize Heap minHeap = [] # for each sentence, maintain top K sentences seen so far for sent in frequencyMap: frequency = frequencyMap[sent] currentObject = FrequencyMap(sent, frequency) if (len(minHeap) == self.k): minObject = remove(minHeap) if (currentObject > minObject): insert(minHeap, currentObject) else: insert(minHeap, minObject) else: insert(minHeap, currentObject) # put the remaining top K sentences in a stack for extracting them in descending order stack = [] while (len(minHeap) > 0): currentObject = remove(minHeap) stack.append(currentObject.sentence) # add to the final list of sentences in descending order finalList = [] while (len(stack) > 0): finalList.append(stack.pop()) # return the top K sentences return finalList
def topKFrequent(self, nums: List[int], k: int) -> List[int]: # edge case checks if (nums == None or len(nums) == 0): return [] # initializations finalResult = [0 for i in range(k)] frequencyMap = {} minHeap = [] # calculate number-count HashMap and then convert to custom class pairs while pushing into Heap for num in nums: if num not in frequencyMap: frequencyMap[num] = 1 else: frequencyMap[num] += 1 # for each number in the Map for number in frequencyMap: # create the pair class object currentPair = NumberFrequencyPair(number, frequencyMap[number]) # insert the element insert(minHeap, currentPair) # if size exceeds k => remove the minimum frequent element if len(minHeap) > k: remove(minHeap) # now, put all top k frequent elements in correct locations (in reverse directions as it is a min heap) for i in range(k - 1, -1, -1): poppedPair = remove(minHeap) finalResult[i] = poppedPair.getNumber() # return the final result return finalResult
def findMinNoOfMeetingRooms(self, intervals: list) -> int: # edge case check if (intervals == None or len(intervals) == 0): return 0 # sort the array based on start times intervals.sort(key=lambda x: x.start) # initialize minHeap with one element minHeap = [intervals[0]] # first check the min end time of elements using minHeap # if next element in sorted array has end time less than min end time => overlapping => add to minHeap # else remove min end time element as no other interval clashes for i in range(1, len(intervals)): minEnd = minHeap[0].end if (intervals[i].start >= minEnd): remove(minHeap) insert(minHeap, intervals[i]) # return the count left in minHeap as those many rooms will be required. return len(minHeap)
def calculate_dijkstra(source: int, layered_graph: LayeredGraph, ) -> Tuple[MultiDiGraph, MultiDiGraph]: node_info = {node: {COST: inf, ARC: None, VISITED: False, DEPTH: inf} for node in layered_graph} node_info[source][COST] = 0 node_info[source][DEPTH] = 0 tree = MultiDiGraph() to_visit = [] insert(to_visit, (0, source)) images = {node: [] for node in layered_graph.origin_nodes} insert(images[layered_graph.origin_node_index(source)], ((0, 0), source)) leafs = set() while len(to_visit) > 0: to_open = extract_minimum(to_visit)[1] if node_info[to_open][VISITED]: continue node_info[to_open][VISITED] = True for arc in layered_graph.out_edges(to_open, data=True): dest = arc[1] if not layered_graph.out_edges(dest): leafs.add(dest) new_cost = node_info[to_open][COST] + arc[2][WEIGHT] new_depth = node_info[to_open][DEPTH] + 1 if node_info[dest][COST] > new_cost: node_info[dest][COST] = new_cost node_info[dest][ARC] = arc node_info[dest][DEPTH] = new_depth insert(to_visit, (new_cost, dest)) insert(images[layered_graph.origin_node_index(dest)], ((new_cost, new_depth), dest)) if tree.has_edge(to_open, dest): # TODO change on link to arc tree.remove_edge(to_open, dest) tree.add_edge(to_open, dest, COST=new_cost) # node_info truncation - усечение дерева not_truncated_tree = MultiDiGraph(tree) while leafs: leaf = leafs.pop() path_cost = node_info[leaf][COST] path_depth = node_info[leaf][DEPTH] if nsmallest(1, images[layered_graph.origin_node_index(leaf)]) != ((path_cost, path_depth), leaf): parent = node_info[leaf][ARC][0] tree.remove_node(leaf) if not tree.out_edges(parent): leafs.add(parent) return tree, not_truncated_tree
def addNum(self, num: int) -> None: # if upper half min heap is empty or current element is greater than its min (=> current element's place # is definitely in upper half whereas not sure about the heap's min element). if ( len(self.upperHalfMinHeap) == 0 or num > self.upperHalfMinHeap[0] ): insert(self.upperHalfMinHeap, num) else: insert(self.lowerHalfMaxHeap, -num) # re-balance according to the sizes while ( abs(len(self.upperHalfMinHeap) - len(self.lowerHalfMaxHeap)) >= 2): if (len(self.upperHalfMinHeap) > len(self.lowerHalfMaxHeap)): number = remove(self.upperHalfMinHeap) insert(self.lowerHalfMaxHeap, -number) else: number = remove(self.lowerHalfMaxHeap) insert(self.upperHalfMinHeap, -number)
def nthUglyNumber(self, n: int) -> int: hashset = set() heap = [] heapq.heappush(heap, 1) hashset.add(1) for i in range(n-1): curr = remove(heap) n2 = 2 * curr n3 = 3 * curr n5 = 5 * curr if n2 not in hashset: hashset.add(n2) insert(heap, n2) if n3 not in hashset: hashset.add(n3) insert(heap, n3) if n5 not in hashset: hashset.add(n5) insert(heap, n5) return remove(heap)
from heapq import heappush as insert, heappop as extract_maximum pq = [] insert(pq, 4) insert(pq, 2) insert(pq, 3) insert(pq, 1) print(extract_maximum(pq)) print(extract_maximum(pq)) print(extract_maximum(pq)) print(extract_maximum(pq))