mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-04-18 19:57:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

lowest_common_ancestor.py static type checking (#2329)

Browse Source 
* adding static type checking to basic_binary_tree.py

* Add static type checking to functions with None return type

* Applying code review comments

* Added missing import statement

* fix spaciing

* "cleaned up depth_of_tree"

* Add doctests and then streamline display() and is_full_binary_tree()

* added static typing to lazy_segment_tree.py

* added missing import statement

* modified variable names for left and right elements

* added static typing to lowest_common_ancestor.py

* fixed formatting

* modified files to meet style guidelines, edited docstrings and added some doctests

* added and fixed doctests in lazy_segment_tree.py

* fixed errors in doctests

Co-authored-by: Christian Clauss <cclauss@me.com>
This commit is contained in:
kanthuc 2020-08-20 21:54:34 -07:00 committed by GitHub
parent d3199da000
commit 2eaacee7b4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 107 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
data_structures/binary_tree/lazy_segment_tree.py
View File

@ -1,84 +1,119 @@
import math import math
from typing import List
class SegmentTree: class SegmentTree:
def __init__(self, N): def __init__(self, N: int) -> None:
self.N = N self.N = N
self.st = [ # approximate the overall size of segment tree with array N
0 for i in range(0, 4 * N) self.st: List[int] = [0 for i in range(0, 4 * N)]
] # approximate the overall size of segment tree with array N # create array to store lazy update
self.lazy = [0 for i in range(0, 4 * N)] # create array to store lazy update self.lazy: List[int] = [0 for i in range(0, 4 * N)]
self.flag = [0 for i in range(0, 4 * N)] # flag for lazy update self.flag: List[int] = [0 for i in range(0, 4 * N)] # flag for lazy update
def left(self, idx): def left(self, idx: int) -> int:
"""
>>> segment_tree = SegmentTree(15)
>>> segment_tree.left(1)
2
>>> segment_tree.left(2)
4
>>> segment_tree.left(12)
24
"""
return idx * 2 return idx * 2
def right(self, idx): def right(self, idx: int) -> int:
"""
>>> segment_tree = SegmentTree(15)
>>> segment_tree.right(1)
3
>>> segment_tree.right(2)
5
>>> segment_tree.right(12)
25
"""
return idx * 2 + 1 return idx * 2 + 1
def build(self, idx, l, r, A): # noqa: E741 def build(
if l == r: # noqa: E741 self, idx: int, left_element: int, right_element: int, A: List[int]
self.st[idx] = A[l - 1] ) -> None:
if left_element == right_element:
self.st[idx] = A[left_element - 1]
else: else:
mid = (l + r) // 2 mid = (left_element + right_element) // 2
self.build(self.left(idx), l, mid, A) self.build(self.left(idx), left_element, mid, A)
self.build(self.right(idx), mid + 1, r, A) self.build(self.right(idx), mid + 1, right_element, A)
self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)]) self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
# update with O(lg N) (Normal segment tree without lazy update will take O(Nlg N) def update(
# for each update) self, idx: int, left_element: int, right_element: int, a: int, b: int, val: int
def update(self, idx, l, r, a, b, val): # noqa: E741 ) -> bool:
""" """
update with O(lg N) (Normal segment tree without lazy update will take O(Nlg N)
for each update)
update(1, 1, N, a, b, v) for update val v to [a,b] update(1, 1, N, a, b, v) for update val v to [a,b]
""" """
if self.flag[idx] is True: if self.flag[idx] is True:
self.st[idx] = self.lazy[idx] self.st[idx] = self.lazy[idx]
self.flag[idx] = False self.flag[idx] = False
if l != r: # noqa: E741 if left_element != right_element:
self.lazy[self.left(idx)] = self.lazy[idx] self.lazy[self.left(idx)] = self.lazy[idx]
self.lazy[self.right(idx)] = self.lazy[idx] self.lazy[self.right(idx)] = self.lazy[idx]
self.flag[self.left(idx)] = True self.flag[self.left(idx)] = True
self.flag[self.right(idx)] = True self.flag[self.right(idx)] = True
if r < a or l > b: if right_element < a or left_element > b:
return True return True
if l >= a and r <= b: # noqa: E741 if left_element >= a and right_element <= b:
self.st[idx] = val self.st[idx] = val
if l != r: # noqa: E741 if left_element != right_element:
self.lazy[self.left(idx)] = val self.lazy[self.left(idx)] = val
self.lazy[self.right(idx)] = val self.lazy[self.right(idx)] = val
self.flag[self.left(idx)] = True self.flag[self.left(idx)] = True
self.flag[self.right(idx)] = True self.flag[self.right(idx)] = True
return True return True
mid = (l + r) // 2 mid = (left_element + right_element) // 2
self.update(self.left(idx), l, mid, a, b, val) self.update(self.left(idx), left_element, mid, a, b, val)
self.update(self.right(idx), mid + 1, r, a, b, val) self.update(self.right(idx), mid + 1, right_element, a, b, val)
self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)]) self.st[idx] = max(self.st[self.left(idx)], self.st[self.right(idx)])
return True return True
# query with O(lg N) # query with O(lg N)
def query(self, idx, l, r, a, b): # noqa: E741 def query(
self, idx: int, left_element: int, right_element: int, a: int, b: int
) -> int:
""" """
query(1, 1, N, a, b) for query max of [a,b] query(1, 1, N, a, b) for query max of [a,b]
>>> A = [1, 2, -4, 7, 3, -5, 6, 11, -20, 9, 14, 15, 5, 2, -8]
>>> segment_tree = SegmentTree(15)
>>> segment_tree.build(1, 1, 15, A)
>>> segment_tree.query(1, 1, 15, 4, 6)
7
>>> segment_tree.query(1, 1, 15, 7, 11)
14
>>> segment_tree.query(1, 1, 15, 7, 12)
15
""" """
if self.flag[idx] is True: if self.flag[idx] is True:
self.st[idx] = self.lazy[idx] self.st[idx] = self.lazy[idx]
self.flag[idx] = False self.flag[idx] = False
if l != r: # noqa: E741 if left_element != right_element:
self.lazy[self.left(idx)] = self.lazy[idx] self.lazy[self.left(idx)] = self.lazy[idx]
self.lazy[self.right(idx)] = self.lazy[idx] self.lazy[self.right(idx)] = self.lazy[idx]
self.flag[self.left(idx)] = True self.flag[self.left(idx)] = True
self.flag[self.right(idx)] = True self.flag[self.right(idx)] = True
if r < a or l > b: if right_element < a or left_element > b:
return -math.inf return -math.inf
if l >= a and r <= b: # noqa: E741 if left_element >= a and right_element <= b:
return self.st[idx] return self.st[idx]
mid = (l + r) // 2 mid = (left_element + right_element) // 2
q1 = self.query(self.left(idx), l, mid, a, b) q1 = self.query(self.left(idx), left_element, mid, a, b)
q2 = self.query(self.right(idx), mid + 1, r, a, b) q2 = self.query(self.right(idx), mid + 1, right_element, a, b)
return max(q1, q2) return max(q1, q2)
def showData(self): def show_data(self) -> None:
showList = [] showList = []
for i in range(1, N + 1): for i in range(1, N + 1):
showList += [self.query(1, 1, self.N, i, i)] showList += [self.query(1, 1, self.N, i, i)]
@ -96,4 +131,4 @@ if __name__ == "__main__":
segt.update(1, 1, N, 1, 3, 111) segt.update(1, 1, N, 1, 3, 111)
print(segt.query(1, 1, N, 1, 15)) print(segt.query(1, 1, N, 1, 15))
segt.update(1, 1, N, 7, 8, 235) segt.update(1, 1, N, 7, 8, 235)
segt.showData() segt.show_data()

56
data_structures/binary_tree/lowest_common_ancestor.py
View File

@ -2,17 +2,29 @@
# https://en.wikipedia.org/wiki/Breadth-first_search # https://en.wikipedia.org/wiki/Breadth-first_search
import queue import queue
from typing import Dict, List, Tuple
def swap(a, b): def swap(a: int, b: int) -> Tuple[int, int]:
"""
Return a tuple (b, a) when given two integers a and b
>>> swap(2,3)
(3, 2)
>>> swap(3,4)
(4, 3)
>>> swap(67, 12)
(12, 67)
"""
a ^= b a ^= b
b ^= a b ^= a
a ^= b a ^= b
return a, b return a, b
# creating sparse table which saves each nodes 2^i-th parent def create_sparse(max_node: int, parent: List[List[int]]) -> List[List[int]]:
def creatSparse(max_node, parent): """
creating sparse table which saves each nodes 2^i-th parent
"""
j = 1 j = 1
while (1 << j) < max_node: while (1 << j) < max_node:
for i in range(1, max_node + 1): for i in range(1, max_node + 1):
@ -22,7 +34,9 @@ def creatSparse(max_node, parent):
# returns lca of node u,v # returns lca of node u,v
def LCA(u, v, level, parent): def lowest_common_ancestor(
u: int, v: int, level: List[int], parent: List[List[int]]
) -> List[List[int]]:
# u must be deeper in the tree than v # u must be deeper in the tree than v
if level[u] < level[v]: if level[u] < level[v]:
u, v = swap(u, v) u, v = swap(u, v)
@ -42,10 +56,18 @@ def LCA(u, v, level, parent):
# runs a breadth first search from root node of the tree # runs a breadth first search from root node of the tree
# sets every nodes direct parent def breadth_first_search(
# parent of root node is set to 0 level: List[int],
# calculates depth of each node from root node parent: List[List[int]],
def bfs(level, parent, max_node, graph, root=1): max_node: int,
graph: Dict[int, int],
root=1,
) -> Tuple[List[int], List[List[int]]]:
"""
sets every nodes direct parent
parent of root node is set to 0
calculates depth of each node from root node
"""
level[root] = 0 level[root] = 0
q = queue.Queue(maxsize=max_node) q = queue.Queue(maxsize=max_node)
q.put(root) q.put(root)
@ -59,7 +81,7 @@ def bfs(level, parent, max_node, graph, root=1):
return level, parent return level, parent
def main(): def main() -> None:
max_node = 13 max_node = 13
# initializing with 0 # initializing with 0
parent = [[0 for _ in range(max_node + 10)] for _ in range(20)] parent = [[0 for _ in range(max_node + 10)] for _ in range(20)]
@ -80,14 +102,14 @@ def main():
12: [], 12: [],
13: [], 13: [],
} }
level, parent = bfs(level, parent, max_node, graph, 1) level, parent = breadth_first_search(level, parent, max_node, graph, 1)
parent = creatSparse(max_node, parent) parent = create_sparse(max_node, parent)
print("LCA of node 1 and 3 is: ", LCA(1, 3, level, parent)) print("LCA of node 1 and 3 is: ", lowest_common_ancestor(1, 3, level, parent))
print("LCA of node 5 and 6 is: ", LCA(5, 6, level, parent)) print("LCA of node 5 and 6 is: ", lowest_common_ancestor(5, 6, level, parent))
print("LCA of node 7 and 11 is: ", LCA(7, 11, level, parent)) print("LCA of node 7 and 11 is: ", lowest_common_ancestor(7, 11, level, parent))
print("LCA of node 6 and 7 is: ", LCA(6, 7, level, parent)) print("LCA of node 6 and 7 is: ", lowest_common_ancestor(6, 7, level, parent))
print("LCA of node 4 and 12 is: ", LCA(4, 12, level, parent)) print("LCA of node 4 and 12 is: ", lowest_common_ancestor(4, 12, level, parent))
print("LCA of node 8 and 8 is: ", LCA(8, 8, level, parent)) print("LCA of node 8 and 8 is: ", lowest_common_ancestor(8, 8, level, parent))
if __name__ == "__main__": if __name__ == "__main__":