Tech for good

[Leetcode/Binary Tree, CBT, PBT] 222. Count Complete Tree Nodes

Diana Kang — Sat, 22 Nov 2025 06:34:48 +0900

Completely Binary Tree (CBT)

Completely Binary Tree: CBT; Perfect Binary Tree: PBT

method 2-case 1

Not-efficient approach - O(n)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0

        return self.countNodes(root.left) + self.countNodes(root.right) + 1

Efficient approach - O(log2n)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        def lheight(node):
            if not node:
                return 0
            return 1 + lheight(node.left)

        def rheight(node):
            if not node:
                return 0
            return 1 + rheight(node.right)
        
        l, r = lheight(root), rheight(root)

        # if it's perfectly balanced
        if l == r:
            return (2**l) - 1
        else:
            return 1 + self.countNodes(root.left) + self.countNodes(root.right)

[Leetcode/Array, Heap (Priority Queue)] 973. K Closest Points to Origin

Diana Kang — Wed, 20 Aug 2025 11:05:38 +0900

class Solution:
    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
        pq = []

        for x, y in points:
            d = x * x + y * y
            pq.append((d, (x,y))) # make it a tuple

        heapify(pq)

        res = []

        for i in range(k):
            res.append(heappop(pq)[1]) # heappop(pq) = (d, (x, y))
        
        return res

[Leetcode/Array, Heap (Priority Queue) 1046. Last Stone Weight

Diana Kang — Tue, 19 Aug 2025 08:52:43 +0900

class Solution:
    def lastStoneWeight(self, stones: List[int]) -> int:
        # what is heap? => find min/max using push() or pop()
        # it allows handling new value effeciently when we even insert new values.
        pq = [-x for x in stones] 
        # pq = [-2, -7, -4, -1, -8, -1]
        
        heapify(pq) # heapify() -> make it into binarry tree for efficiency (only half-through traversal)

        while len(pq) > 1:
            heaviest = -1 * heappop(pq)
            second_heaviest = -1 * heappop(pq)

            if heaviest != second_heaviest:
                new_weight = (heaviest - second_heaviest)
                heappush(pq, -1 * new_weight)
            
        return -1 * pq[0] if len(pq) > 0 else 0

[Codepath/BFS, Graph] Count Connected Components

Diana Kang — Tue, 12 Aug 2025 01:11:57 +0900

def count_components(adjacency_dict):
    # Write your code here
    visited = set()
    cnt = 0
    
    def dfs(node):
        visited.add(node)
        for neighbor in adjacency_dict[node]:
            if neighbor not in visited:
                dfs(neighbor)
    
    for node in adjacency_dict:
        if node not in visited:
            dfs(node)
            cnt += 1
    
    return cnt

[Codepath/BFS, Graph] Find Path

Diana Kang — Tue, 12 Aug 2025 00:53:42 +0900

from collections import deque, defaultdict

def has_path(adjacency_dict, start, destination):
    # Write your code here
    if start == destination:
        return True
        
    graph = defaultdict(list, adjacency_dict)
    
    q = deque([start])
    visited = set([start])

    while q:
        curr = q.popleft()
        
        if curr == destination:
            return True
        
        for neighbor in graph[curr]:
            if neighbor not in visited:
                visited.add(neighbor)
                q.append(neighbor)
    
    return False

[Leetcode/DFS, BFS, Graph, Matrix] 200. Number of Islands

Diana Kang — Sat, 9 Aug 2025 07:00:55 +0900

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        n_rows, n_cols = len(grid), len(grid[0])

        res = 0
        visited = set()

        def dfs(r, c):
            visited.add((r,c))

            neighbors = [(r-1, c), (r+1, c), (r, c-1), (r, c+1)]

            # check if visited or not
            for n_r, n_c in neighbors:
                if n_r in range(n_rows) and n_c in range(n_cols):
                    if grid[n_r][n_c] == "1" and (n_r, n_c) not in visited:
                        dfs(n_r, n_c)
        
        # check grid one by one
        for r in range(n_rows):
            for c in range(n_cols):
                # If the cell is land and not visited, it's a new island
                if grid[r][c] == "1" and (r,c) not in visited:
                    # # Explore the entire island using DFS
                    dfs(r,c)
                    # # Increase the island count
                    res += 1

        return res

[Leetcode/DFS, BFS, Graph] 1971. Find if Path Exists in Graph

Diana Kang — Fri, 8 Aug 2025 11:05:34 +0900

class Solution:
    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
        # 1. Make a graph
        ## To figure out neighbor using hash-map
        ## 0 => [1,2]

        graph = defaultdict(list)

        for u, v in edges:
            graph[u].append(v)
            graph[v].append(u)

        # 2. BFS from source
        q = deque([source])
        visited = set([source])

        while q:
            curr = q.popleft()

            if curr == destination:
                return True
            
            for neighbor in graph[curr]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    q.append(neighbor)

        return False

[Leetcode/Array, Hash Table, Graph] 997. Find the Town Judge

Diana Kang — Fri, 8 Aug 2025 10:59:12 +0900

Properties 1
- The town judge trusts nobody.
Properties 2
- Everybody (except for the town judge) trusts the town judge.
Properties 3
- There is exactly one person that satisfies properties 1 and 2.

class Solution:
    def findJudge(self, n: int, trust: List[List[int]]) -> int:
        #  To figure out in-degree/out-degree using hash-map
        in_degree = defaultdict(int)
        out_degree = defaultdict(int)
        
        # for p0 = pair(trust)[0], p1 = pair(trust)[1]
        for p0,p1 in trust:
            in_degree[p1] += 1
            out_degree[p0] += 1
        
        for i in range(1, n+1):
            # indegree[i] == n-1 => properties 2
            # outdegree[i] == 0 => properties 1
            if in_degree[i] == n-1 and out_degree[i] == 0:
                return i

        return -1

[HackerRank] Inorder Traversal of Binary Tree

Diana Kang — Mon, 4 Aug 2025 05:49:43 +0900

[Leetcode/Tree, Binary Tree, DFS] 572. Subtree of Another Tree

Diana Kang — Sat, 26 Jul 2025 04:54:54 +0900

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        if not root:
            return False
        return self.sameTree(root, subRoot) or self.isSubtree(root.left, subRoot) or self.isSubtree(root.right, subRoot)
    
    def sameTree(self, root1, root2):
        if not root1 and not root2:
            return True
        if not root1 or not root2:
            return False
        return root1.val == root2.val and self.sameTree(root1.left, root2.left) and self.sameTree(root1.right, root2.right)