LeetCode problem 3396

Mehemmed — Tue, 08 Apr 2025 18:03:37 +0000

In this post, I’ll walk through my two solutions to LeetCode Problem 3396: Minimum Number of Operations to Make Elements in Array Distinct, using pythonic a algorithmic approach. Each method has its own strengths, and I explain how I used them to solve the problem cleanly in Python.

🧠 Problem Overview

Our goal in this problem is to make all the elements in an array distinct. There is only one operation we can do which is remove the first 3 elements of the array and we need to find minimum number of operations to achieve uniqueness in our array.

First Approach: Pythonic

In this approach, I use the power of **set **to check for uniqueness. A set is a data structure that only contains unique elements, which means if we convert a list to a set, any duplicate elements will automatically be removed.

I keep removing the first 3 elements from the list until the length of the list becomes equal to the length of the set created from it — which means all elements are now distinct.

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        res = 0
        while not len(nums) == len(set(nums)):
            res += 1
            nums = nums[3:]

        return res

✅ Pros:

Very readable and short.
Makes good use of Python’s built-in features.

⚠️ Cons:

Inefficient for large inputs because slicing nums = nums[3:] creates a new list every time (O(n) per operation).
Not optimal in terms of performance.

Second Approach: Algorithmic

For a more efficient approach, I switched to using a set to track seen elements and two pointers (i and j). When a duplicate is found, I clear the set and move the window forward by 3 (simulating the removal operation). This gives us better performance, especially on longer arrays.

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        s = set()

        j, i = 0, 0
        while j < len(nums):
            if nums[j] not in s:
                s.add(nums[j])
                j += 1
            else:
                s.clear()
                i += 3
                j = i
        return i // 3

✅ Pros:

Efficient: only one pass through the array (O(n) time).
Doesn’t create unnecessary intermediate arrays.
Scales well for large inputs.

⚠️ Cons:

Slightly more code than the Pythonic approach.
Requires a bit more thought to understand at first glance.

🧩 Final Thoughts

Both solutions get the job done, but depending on the context (e.g., interview, production code, or learning), one may be preferable over the other. The Pythonic approach shines with its elegance, while the algorithmic one is the go-to when performance matters.

LeetCode 993: Cousins in Binary Tree – DFS and BFS Approaches Explained (Python)

Mehemmed — Fri, 21 Mar 2025 18:00:30 +0000

LeetCode 993: Cousins in Binary Tree – DFS and BFS Explained (Python)

In this post, I’ll walk through my two solutions to LeetCode Problem 993: Cousins in Binary Tree, using both a recursive DFS approach and an *iterative BFS * approach. Each method has its own strengths, and I explain how I used them to solve the problem cleanly in Python.

🧠 Problem Overview

Two nodes of a binary tree are cousins if they have the same depth but different parents.

Given the root of a binary tree with unique values, and the values of two different nodes x and y, return True if they are cousins, False otherwise.

Overall approach

It is guaranteed that nodes with the value x and y exists, so in each of the 2 solutions we should make sure that those nodes' parents and depths are tracked and compared correctly

First approach DFS: Depth First Search

We define helper function called findNodeDepth which recursively searches for the node first in left subtree, if not found, function searches it in right subtree. When the node is found its depth and parent is returned

Here is the full code:

def isCousins(self, root, x, y):
    depth1, parent1 = self.findNodeDepth(root, x, 0, None)
    depth2, parent2 = self.findNodeDepth(root, y, 0, None)

    if (depth1 == depth2 and parent1 != parent2): 
        return True
    return False

def findNodeDepth(self, root, x, depth, prev):
    if root == None: 
        return None
    if root.val == x: 
        return (depth, prev)

    left = self.findNodeDepth(root.left, x, depth + 1, root)
    if left: return left

    return self.findNodeDepth(root.right, x, depth + 1, root)

At the end it compares their depth and parent according to the problem statement such that it will return True if their depth are equal and parents are different, False otherwise.

Second Approach: Breadth-First Search

Overall logic is similar but this time we traverse the tree such that nodes in the same depth are visited first, which makes sense to do if we are looking for cousins.

Here's the full code:

from collections import deque

def isCousins(self, root, x, y):
    queue = deque()
    queue.append((root, None, 0))  # (node, parent, depth)

    node1, node2 = None, None

    while queue:
        size = len(queue)
        for _ in range(size):
            node, parent, depth = queue.popleft()

            if node.val == x:
                node1 = (node, parent, depth)
            elif node.val == y:
                node2 = (node, parent, depth)

            if node.left:
                queue.append((node.left, node, depth + 1))
            if node.right:
                queue.append((node.right, node, depth + 1))

        if node1 and node2:
            return node1[1] != node2[1] and node1[2] == node2[2]
        elif node1 or node2:
            return False

    return False

Perfect for checking whether two nodes are at the same level, and have different parents.

Final Thoughts

Writing out both helped me understand how traversal methods affect problem-solving in trees — and I recommend trying both when you study similar problems.

Let's Connect

If you liked this breakdown, feel free to follow me.
I’ll be sharing more clean solutions and dev thoughts regularly.

DEV Community: Mehemmed

LeetCode problem 3396

🧠 Problem Overview

First Approach: Pythonic

Second Approach: Algorithmic

LeetCode 993: Cousins in Binary Tree – DFS and BFS Approaches Explained (Python)

LeetCode 993: Cousins in Binary Tree – DFS and BFS Explained (Python)

🧠 Problem Overview

Overall approach

First approach DFS: Depth First Search

Second Approach: Breadth-First Search

Final Thoughts

Let's Connect