algorithm/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2025-07-05 09:21:13 +08: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
2 changed files with 107 additions and 50 deletions
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
from typing import List
class SegmentTree:
def __init__(self, N):
def __init__(self, N: int) -> None:
self.N = N
self.st = [
0 for i in range(0, 4 * N)
] # approximate the overall size of segment tree with array N
self.lazy = [0 for i in range(0, 4 * N)] # create array to store lazy update
self.flag = [0 for i in range(0, 4 * N)] # flag for lazy update
# approximate the overall size of segment tree with array N
self.st: List[int] = [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: 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
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
def build(self, idx, l, r, A): # noqa: E741
if l == r: # noqa: E741
self.st[idx] = A[l - 1]
def build(
self, idx: int, left_element: int, right_element: int, A: List[int]
) -> None:
if left_element == right_element:
self.st[idx] = A[left_element - 1]
else:
mid = (l + r) // 2
self.build(self.left(idx), l, mid, A)
self.build(self.right(idx), mid + 1, r, A)
mid = (left_element + right_element) // 2
self.build(self.left(idx), left_element, mid, 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)])
# update with O(lg N) (Normal segment tree without lazy update will take O(Nlg N)
# for each update)
def update(self, idx, l, r, a, b, val): # noqa: E741
def update(
self, idx: int, left_element: int, right_element: int, a: int, b: int, val: int
) -> 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]
"""
if self.flag[idx] is True:
self.st[idx] = self.lazy[idx]
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.right(idx)] = self.lazy[idx]
self.flag[self.left(idx)] = True
self.flag[self.right(idx)] = True
if r < a or l > b:
if right_element < a or left_element > b:
return True
if l >= a and r <= b: # noqa: E741
if left_element >= a and right_element <= b:
self.st[idx] = val
if l != r: # noqa: E741
if left_element != right_element:
self.lazy[self.left(idx)] = val
self.lazy[self.right(idx)] = val
self.flag[self.left(idx)] = True
self.flag[self.right(idx)] = True
return True
mid = (l + r) // 2
self.update(self.left(idx), l, mid, a, b, val)
self.update(self.right(idx), mid + 1, r, a, b, val)
mid = (left_element + right_element) // 2
self.update(self.left(idx), left_element, mid, 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)])
return True
# 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]
>>> 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:
self.st[idx] = self.lazy[idx]
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.right(idx)] = self.lazy[idx]
self.flag[self.left(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
if l >= a and r <= b: # noqa: E741
if left_element >= a and right_element <= b:
return self.st[idx]
mid = (l + r) // 2
q1 = self.query(self.left(idx), l, mid, a, b)
q2 = self.query(self.right(idx), mid + 1, r, a, b)
mid = (left_element + right_element) // 2
q1 = self.query(self.left(idx), left_element, mid, a, b)
q2 = self.query(self.right(idx), mid + 1, right_element, a, b)
return max(q1, q2)
def showData(self):
def show_data(self) -> None:
showList = []
for i in range(1, N + 1):
showList += [self.query(1, 1, self.N, i, i)]
@ -96,4 +131,4 @@ if __name__ == "__main__":
segt.update(1, 1, N, 1, 3, 111)
print(segt.query(1, 1, N, 1, 15))
segt.update(1, 1, N, 7, 8, 235)
segt.showData()
segt.show_data()