Reine

Author: Prakash-sa

Binary Tree/Binary Lifting/1483. Kth Ancestor of a Tree Node.py

@@ -0,0 +1,60 @@
+# https://leetcode.com/problems/kth-ancestor-of-a-tree-node/description/
+
+"""
+You are given a tree with n nodes numbered from 0 to n - 1 in the form of a parent array parent where parent[i] is the parent of ith node. The root of the tree is node 0. Find the kth ancestor of a given node.
+The kth ancestor of a tree node is the kth node in the path from that node to the root node.
+Implement the TreeAncestor class:
+TreeAncestor(int n, int[] parent) Initializes the object with the number of nodes in the tree and the parent array.
+int getKthAncestor(int node, int k) return the kth ancestor of the given node node. If there is no such ancestor, return -1.
+
+Example 1:
+Input
+["TreeAncestor", "getKthAncestor", "getKthAncestor", "getKthAncestor"]
+[[7, [-1, 0, 0, 1, 1, 2, 2]], [3, 1], [5, 2], [6, 3]]
+Output
+[null, 1, 0, -1]
+
+Explanation
+TreeAncestor treeAncestor = new TreeAncestor(7, [-1, 0, 0, 1, 1, 2, 2]);
+treeAncestor.getKthAncestor(3, 1); // returns 1 which is the parent of 3
+treeAncestor.getKthAncestor(5, 2); // returns 0 which is the grandparent of 5
+treeAncestor.getKthAncestor(6, 3); // returns -1 because there is no such ancestor
+
+Constraints:
+1 <= k <= n <= 5 * 104
+parent.length == n
+parent[0] == -1
+0 <= parent[i] < n for all 0 < i < n
+0 <= node < n
+There will be at most 5 * 104 queries.
+"""
+
+
+class TreeAncestor:
+
+    def __init__(self, n: int, parent: List[int]):
+        m = 1 + int(log2(n))  # at most 16 for this problem
+        self.dp = [[-1] * m for _ in range(n)]  # ith node's 2^j parent
+        for j in range(m):
+            for i in range(n):
+                if j == 0:
+                    self.dp[i][0] = parent[i]  # 2^0 parent
+                elif self.dp[i][j - 1] != -1:
+                    self.dp[i][j] = self.dp[self.dp[i][j - 1]][j - 1]
+
+    def getKthAncestor(self, node: int, k: int) -> int:
+        while k > 0 and node != -1:
+            i = int(log2(k))
+            node = self.dp[node][i]
+            k -= 1 << i
+        return node
+
+'''
+For node 0, 1, ..., n-1, we define a matrix self.dp[][] whose i, jth element indicates the ith node's 2^j parent. Here, i = 0, 1, ..., n-1 and j = 0, 1, ..., int(log2(n)). An important recursive relationship is that
+
+self.dp[i][j] = self.dp[self.dp[i][j-1]][j-1].
+
+In other words, ith node's 2^j parent is ith node's 2^(j-1) parent's 2^(j-1) parent. In this way, lookup is guarenteed to complete in O(logN) time. Note that it takes O(NlogN) to build self.dp.
+
+Time complexity O(NlogN) to pre-processing the tree and O(logN) for each equery thereafter.
+'''

Binary Tree/Binary Lifting/3559. Number of Ways to Assign Edge Weights II.py

@@ -0,0 +1,124 @@
+# https://leetcode.com/problems/number-of-ways-to-assign-edge-weights-ii/description/
+
+
+"""
+There is an undirected tree with n nodes labeled from 1 to n, rooted at node 1. The tree is represented by a 2D integer array edges of length n - 1, where edges[i] = [ui, vi] indicates that there is an edge between nodes ui and vi.
+Initially, all edges have a weight of 0. You must assign each edge a weight of either 1 or 2.
+The cost of a path between any two nodes u and v is the total weight of all edges in the path connecting them.
+You are given a 2D integer array queries. For each queries[i] = [ui, vi], determine the number of ways to assign weights to edges in the path such that the cost of the path between ui and vi is odd.
+Return an array answer, where answer[i] is the number of valid assignments for queries[i].
+Since the answer may be large, apply modulo 109 + 7 to each answer[i].
+Note: For each query, disregard all edges not in the path between node ui and vi.
+
+Example 1:
+Input: edges = [[1,2]], queries = [[1,1],[1,2]]
+Output: [0,1]
+Explanation:
+Query [1,1]: The path from Node 1 to itself consists of no edges, so the cost is 0. Thus, the number of valid assignments is 0.
+Query [1,2]: The path from Node 1 to Node 2 consists of one edge (1 → 2). Assigning weight 1 makes the cost odd, while 2 makes it even. Thus, the number of valid assignments is 1.
+
+Example 2:
+Input: edges = [[1,2],[1,3],[3,4],[3,5]], queries = [[1,4],[3,4],[2,5]]
+Output: [2,1,4]
+Explanation:
+Query [1,4]: The path from Node 1 to Node 4 consists of two edges (1 → 3 and 3 → 4). Assigning weights (1,2) or (2,1) results in an odd cost. Thus, the number of valid assignments is 2.
+Query [3,4]: The path from Node 3 to Node 4 consists of one edge (3 → 4). Assigning weight 1 makes the cost odd, while 2 makes it even. Thus, the number of valid assignments is 1.
+Query [2,5]: The path from Node 2 to Node 5 consists of three edges (2 → 1, 1 → 3, and 3 → 5). Assigning (1,2,2), (2,1,2), (2,2,1), or (1,1,1) makes the cost odd. Thus, the number of valid assignments is 4.
+
+
+Constraints:
+2 <= n <= 105
+edges.length == n - 1
+edges[i] == [ui, vi]
+1 <= queries.length <= 105
+queries[i] == [ui, vi]
+1 <= ui, vi <= n
+edges represents a valid tree.
+"""
+
+
+class Solution:
+    MOD = 10**9 + 7
+
+    def modPow(self, a, b):
+        ans = 1
+        while b > 0:
+            if b & 1:
+                ans = (ans * a) % self.MOD
+            a = (a * a) % self.MOD
+            b >>= 1
+        return ans
+
+    def dfs(self, node, parent):
+        self.up[node][0] = parent
+
+        for j in range(1, self.LOG):
+            self.up[node][j] = self.up[self.up[node][j - 1]][j - 1]
+
+        for neighbour in self.adj[node]:
+            if neighbour == parent:
+                continue
+
+            self.depth[neighbour] = self.depth[node] + 1
+            self.dfs(neighbour, node)
+
+    def lca(self, u, v):
+        if self.depth[u] < self.depth[v]:
+            u, v = v, u
+
+        diff = self.depth[u] - self.depth[v]
+
+        for j in range(self.LOG - 1, -1, -1):
+            if diff & (1 << j):
+                u = self.up[u][j]
+
+        if u == v:
+            return u
+
+        for j in range(self.LOG - 1, -1, -1):
+            if self.up[u][j] != self.up[v][j]:
+                u = self.up[u][j]
+                v = self.up[v][j]
+        return self.up[u][0]
+
+    def assignEdgeWeights(
+        self, edges: List[List[int]], queries: List[List[int]]
+    ) -> List[int]:
+        n = len(edges) + 1
+
+        self.LOG = 1
+        while (1 << self.LOG) <= n:
+            self.LOG += 1
+
+        self.adj = [[] for _ in range(n + 1)]
+
+        for u, v in edges:
+            self.adj[u].append(v)
+            self.adj[v].append(u)
+
+        self.depth = [0] * (n + 1)
+        self.up = [[0] * self.LOG for _ in range(n + 1)]
+
+        self.dfs(1, 0)
+        ans = []
+
+        for u, v in queries:
+            L = self.lca(u, v)
+            dist = self.depth[u] + self.depth[v] - 2 * self.depth[L]
+
+            if dist == 0:
+                ans.append(0)
+            else:
+                ans.append(self.modPow(2, dist - 1))
+        return ans
+
+"""
+Complexity Analysis
+Let n be the number of nodes in the tree, and let m be the number of queries.
+
+Time complexity: O(nlogn+mlogn).
+Building the binary lifting table requires O(nlogn) time. Each LCA query takes O(logn) time, resulting in a total query cost of O(mlogn).
+
+Space complexity: O(nlogn).
+The binary lifting table stores O(logn) ancestors for each node, requiring O(nlogn) space.
+"""

Binary Tree/Binary Lifting/Binary Lifting.md

@@ -0,0 +1,4 @@
+[Video](https://www.youtube.com/watch?v=WTtuOj6FXE8&t=1s)
+
+[Video 2](https://www.youtube.com/watch?v=k5tS37rLCBs)
+

Graph/Dijkastra Algo/743. Network Delay Time.py

@@ -31,7 +31,7 @@ def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
 
         adj=[[] for _ in range(n+1)]
 
-        for u,v, w in times:
+        for u,v,w in times:
             adj[u].append((v,w))
 
         h=[(0,k)]
@@ -57,9 +57,13 @@ def networkDelayTime(self, times: List[List[int]], n: int, k: int) -> int:
 # Here N is the number of nodes and E is the number of total edges in the given network.
 # Time complexity: O(N+ElogN)
 # Dijkstra's Algorithm takes O(ElogN). Finding the minimum time required in signalReceivedAt takes O(N).
-# The maximum number of vertices that could be added to the priority queue is E. Thus, push and pop operations on the priority queue take O(logE) time. The value of E can be at most N⋅(N−1). Therefore, O(logE) is equivalent to O(logN 2 ) which in turn equivalent to O(2⋅logN). Hence, the time complexity for priority queue operations equals O(logN).
-# Although the number of vertices in the priority queue could be equal to E, we will only visit each vertex only once. If we encounter a vertex for the second time, then currNodeTime will be greater than signalReceivedAt[currNode], and we can continue to the next vertex in the priority queue. Hence, in total E edges will be traversed and for each edge, there could be one priority queue insertion operation.
+# The maximum number of vertices that could be added to the priority queue is E. Thus, push and pop operations on the priority queue take O(logE) time. 
+# The value of E can be at most N⋅(N−1). Therefore, O(logE) is equivalent to O(logN^2 ) which in turn equivalent to O(2⋅logN). 
+# Hence, the time complexity for priority queue operations equals O(logN).
+# Although the number of vertices in the priority queue could be equal to E, we will only visit each vertex only once.
+# If we encounter a vertex for the second time, then currNodeTime will be greater than signalReceivedAt[currNode], and we can continue to the next vertex in the priority queue.
+# Hence, in total E edges will be traversed and for each edge, there could be one priority queue insertion operation.
 # Hence, the time complexity is equal to O(N+ElogN).
 
 # Space complexity: O(N+E)
-# Building the adjacency list will take O(E) space. Dijkstra's algorithm takes O(E) space for priority queue because each vertex could be added to the priority queue N−1 time which makes it N∗(N−1) and O(N 2) is equivalent to O(E). signalReceivedAt takes O(N) space.
+# Building the adjacency list will take O(E) space. Dijkstra's algorithm takes O(E) space for priority queue because each vertex could be added to the priority queue N−1 time which makes it N*(N−1) and O(N^2) is equivalent to O(E). signalReceivedAt takes O(N) space.

Graph/Topological Sort/269. Alien Dictionary.py

@@ -70,7 +70,5 @@ def alienOrder(self, words: List[str]) -> str:
 # O(T) where T = total number of characters in input
 # Final Total Time Complexity: O(T+E)
 
-
-
 # Time Complexity:O(T+E)(effectively O(T))
-# Space Complexity: O(U+E)(effectively O(1))
+# Space Complexity: O(U+E)(effectively O(1))

Heap/347. Top K Frequent Elements.py

@@ -40,20 +40,31 @@ def topKFrequent(self, nums: List[int], k: int) -> List[int]:
 
 
 from collections import Counter
+from typing import List
 
-def topKFrequent(nums, k):
-    freq = Counter(nums)
-    buckets = [[] for _ in range(len(nums) + 1)]
 
-    for num, count in freq.items():
-        buckets[count].append(num)
+class Solution:
+    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
+        freq = Counter(nums)
+
+        # buckets[i] contains all numbers that appear exactly i times
+        buckets = [[] for _ in range(len(nums) + 1)]
+
+        for num, count in freq.items():
+            buckets[count].append(num)
+
+        result = []
+
+        # Traverse from highest frequency to lowest frequency
+        for count in range(len(nums), 0, -1):
+            for num in buckets[count]:
+                result.append(num)
+
+                if len(result) == k:
+                    return result
+
+        return result
 
-    result = []
-    for i in range(len(buckets) - 1, -1, -1):
-        for num in buckets[i]:
-            result.append(num)
-            if len(result) == k:
-                return result
 
 # Bucket Sort
 # O(n)

Segment Trees/1584. Min Cost to Connect All Points.py

@@ -0,0 +1,113 @@
+# https://leetcode.com/problems/min-cost-to-connect-all-points/description/
+
+
+"""
+You are given an array points representing integer coordinates of some points on a 2D-plane, where points[i] = [xi, yi].
+The cost of connecting two points [xi, yi] and [xj, yj] is the manhattan distance between them: |xi - xj| + |yi - yj|, where |val| denotes the absolute value of val.
+Return the minimum cost to make all points connected. All points are connected if there is exactly one simple path between any two points.
+
+Example 1:
+Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]]
+Output: 20
+Explanation:
+We can connect the points as shown above to get the minimum cost of 20.
+Notice that there is a unique path between every pair of points.
+
+Example 2:
+Input: points = [[3,12],[-2,5],[-4,1]]
+Output: 18
+
+Constraints:
+1 <= points.length <= 1000
+-106 <= xi, yi <= 106
+All pairs (xi, yi) are distinct.
+"""
+
+
+class Solution:
+    def minCostConnectPoints(self, points: List[List[int]]) -> int:
+        n = len(points)
+        h = [(0, 0)]  # cost, point
+        in_mst = [False] * n
+        mst_cost = 0
+        edges_used = 0
+        while edges_used < n:
+            w, curr_node = heappop(h)
+
+            if in_mst[curr_node]:
+                continue
+            in_mst[curr_node] = True
+            mst_cost += w
+            edges_used += 1
+            for next_node in range(n):
+                if not in_mst[next_node]:
+                    next_w = abs(points[curr_node][0] - points[next_node][0]) + abs(
+                        points[curr_node][1] - points[next_node][1]
+                    )
+                    heappush(h, (next_w, next_node))
+        return mst_cost
+
+"""
+Complexity Analysis
+
+If N is the number of points in the input array.
+
+Time complexity: O(N^2⋅log(N)).
+In the worst-case, we push/pop N⋅(N−1)/2≈N^2 edges of our graph in the heap. Each push/pop operation takes O(log(N^2))≈log(N) time.
+Thus, the overall time complexity is O(N^2 ⋅log(N)).
+
+Space complexity: O(N^2).
+In the worst-case, we push N⋅(N−1)/2≈N^2 edges into the heap.
+We use an array inMST of size N to mark which nodes are included in MST.
+Thus, the overall space complexity is O(N^2+N)≈O(N^2).
+"""
+
+class Solution:
+    def minCostConnectPoints(self, points: List[List[int]]) -> int:
+        n = len(points)
+        mst_cost = 0
+        edges_used = 0
+
+        # Track nodes which are visited.
+        in_mst = [False] * n
+
+        min_dist = [math.inf] * n
+        min_dist[0] = 0
+
+        while edges_used < n:
+            curr_min_edge = math.inf
+            curr_node = -1
+
+            # Pick least weight node which is not in MST.
+            for node in range(n):
+                if not in_mst[node] and curr_min_edge > min_dist[node]:
+                    curr_min_edge = min_dist[node]
+                    curr_node = node
+
+            mst_cost += curr_min_edge
+            edges_used += 1
+            in_mst[curr_node] = True
+
+            # Update adjacent nodes of current node.
+            for next_node in range(n):
+                weight = abs(points[curr_node][0] - points[next_node][0]) + abs(
+                    points[curr_node][1] - points[next_node][1]
+                )
+
+                if not in_mst[next_node] and min_dist[next_node] > weight:
+                    min_dist[next_node] = weight
+
+        return mst_cost
+
+'''
+Complexity Analysis
+If N is the number of points in the input array.
+
+Time complexity: O(N^2).
+We pick all N nodes one by one to include in the MST. Picking each node takes O(N) time and after picking a node, we iterate over all of its adjacent nodes, which also takes O(N) time.
+Thus, the overall time complexity is O(N⋅(N+N))=O(N^2).
+Space complexity: O(N).
+
+We use two arrays each of size N, inMST and minDist.
+Thus, the overall space complexity is O(N+N)=O(N).
+'''