Stop reading about algorithms.
Watch them execute.

1def trap(height: List[int]) -> int:
2    if not height: return 0
3    l, r = 0, len(height) - 1
4    leftMax, rightMax = height[l], height[r]
5    res = 0
6
7    while l < r:
8        if leftMax < rightMax:
9            l += 1
10            leftMax = max(leftMax, height[l])
11            res += leftMax - height[l]
12        else:
13            r -= 1
14            rightMax = max(rightMax, height[r])
15            res += rightMax - height[r]
16    return res

1def minCostConnectPoints(points: list[list[int]]) -> int:
2    N = len(points)
3    adj = {i: [] for i in range(N)}
4    for i in range(N):
5        x1, y1 = points[i]
6        for j in range(i + 1, N):
7            x2, y2 = points[j]
8            dist = abs(x1 - x2) + abs(y1 - y2)
9            adj[i].append([dist, j])
10            adj[j].append([dist, i])
11
12    res = 0
13    visit = set()
14    minHeap = [[0, 0]] # [cost, point]
15    while len(visit) < N:
16        cost, i = heapq.heappop(minHeap)
17        if i in visit:
18            continue
19        res += cost
20        visit.add(i)
21        for d, n in adj[i]:
22            if n not in visit:
23                heapq.heappush(minHeap, [d, n])
24    return res

1def maxAreaOfIsland(grid: list[list[int]]) -> int:
2    ROWS, COLS = len(grid), len(grid[0])
3    visit = set()
4
5    def dfs(r, c):
6        if r < 0 or c < 0 or r == ROWS or c == COLS or            grid[r][c] == 0 or (r, c) in visit:
7            return 0
8        visit.add((r, c))
9        return 1 + dfs(r + 1, c) + dfs(r - 1, c) +                    dfs(r, c + 1) + dfs(r, c - 1)
10
11    area = 0
12    for r in range(ROWS):
13        for c in range(COLS):
14            area = max(area, dfs(r, c))
15    return area

1def isValidSudoku(board: List[List[str]]) -> bool:
2    rows = collections.defaultdict(set)
3    cols = collections.defaultdict(set)
4    squares = collections.defaultdict(set) # key = (r/3, c/3)
5
6    for r in range(9):
7        for c in range(9):
8            if board[r][c] == ".":
9                continue
10            if (board[r][c] in rows[r] or
11                board[r][c] in cols[c] or
12                board[r][c] in squares[(r//3, c//3)]):
13                return False
14            cols[c].add(board[r][c])
15            rows[r].add(board[r][c])
16            squares[(r//3, c//3)].add(board[r][c])
17            
18    return True

1def change(amount: int, coins: List[int]) -> int:
2    n = len(coins)
3    dp = [[0] * (amount + 1) for _ in range(n + 1)]
4
5    for i in range(n + 1):
6        dp[i][0] = 1
7
8    for i in range(n - 1, -1, -1):
9        for a in range(1, amount + 1):
10            dp[i][a] = dp[i + 1][a]
11            if coins[i] <= a:
12                dp[i][a] += dp[i][a - coins[i]]
13
14    return dp[0][amount]

1def largestRectangleArea(heights: list[int]) -> int:
2    maxArea = 0
3    stack = []  # (start_index, height)
4
5    for i, h in enumerate(heights):
6        start = i
7        while stack and stack[-1][1] > h:
8            idx, height = stack.pop()
9            maxArea = max(maxArea, height * (i - idx))
10            start = idx
11        stack.append((start, h))
12
13    for idx, height in stack:
14        maxArea = max(maxArea, height * (len(heights) - idx))
15
16    return maxArea