# LeetCode — Set Matrix Zeroes

Given an `m x n` integer matrix `matrix`, if an element is `0`, set its entire row and column to `0`'s.

You must do it in place.

Example 1:

`Input: matrix = [[1,1,1],[1,0,1],[1,1,1]]Output: [[1,0,1],[0,0,0],[1,0,1]]`

Example 2:

--

--

# LeetCode — Reorder List (Blind Curated 45)

You are given the head of a singly linked-list. The list can be represented as:

`L0 → L1 → … → Ln - 1 → Ln`

Reorder the list to be on the following form:

`L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …`

You may not modify the values in the list’s nodes. Only nodes themselves may be changed.

Example 1:

`Input: head = [1,2,3,4]Output: [1,4,2,3]`

Example 2:

--

--

# LeetCode — Remove Nth Node From End of List

Given the `head` of a linked list, remove the `nth` node from the end of the list and return its head.

Example 1:

`Input: head = [1,2,3,4,5], n = 2Output: [1,2,3,5]`

Example 2:

`Input: head = [1], n = 1Output: []`

Example 3:

`Input: head = [1,2], n = 1Output: [1]`

Constraints:

• The number of nodes in the list is `sz`.
• `1 <= sz <= 30`
• `0 <= Node.val <= 100`
• `1 <= n <= sz`

Solution:

Time complexity: O(N)

Space complexity: O(N)

--

--

# LeetCode — Merge K sorted lists (Blind Curated 43)

You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.

Merge all the linked-lists into one sorted linked-list and return it.

Example 1:

`Input: lists = [[1,4,5],[1,3,4],[2,6]]Output: [1,1,2,3,4,4,5,6]Explanation: The linked-lists are:[  1->4->5,  1->3->4,  2->6]merging them into one sorted list:1->1->2->3->4->4->5->6`

Example 2:

`Input: lists = []Output: []`

Example 3:

`Input: lists = [[]]Output: []`

Constraints:

• `k == lists.length`
• `0 <= k <= 104`
• `0 <= lists[i].length <= 500`
• `-104 <= lists[i][j] <= 104`
• `lists[i]` is sorted in ascending order.
• The sum of `lists[i].length` will not exceed `104`.

Solution:

Time complexity: O(N)

Space complexity: O(LogN)

--

--

# LeetCode — Non-overlapping intervals (Blind Curated 37)

Given an array of intervals `intervals` where `intervals[i] = [starti, endi]`, return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

Example 1:

`Input: intervals = [[1,2],[2,3],[3,4],[1,3]]Output: 1Explanation: [1,3] can be removed and the rest of the intervals are non-overlapping.`

Example 2:

`Input: intervals = [[1,2],[1,2],[1,2]]Output: 2Explanation: You need to remove two [1,2] to make the rest of the intervals non-overlapping.`

Example 3:

`Input: intervals = [[1,2],[2,3]]Output: 0Explanation: You don't need to remove any of the intervals since they're already non-overlapping.`

Constraints:

• `1 <= intervals.length <= 105`
• `intervals[i].length == 2`
• `-5 * 104 <= starti < endi <= 5 * 104`

Solution:

Time complexity: O(N)

Space complexity: O(N)

--

--

# LeetCode — Longest consecutive sequence (Blind Curated 31)

Given an unsorted array of integers `nums`, return the length of the longest consecutive elements sequence.

You must write an algorithm that runs in `O(n)` time.

Example 1:

`Input: nums = [100,4,200,1,3,2]Output: 4Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.`

Example 2:

`Input: nums = [0,3,7,2,5,8,4,6,0,1]Output: 9`

Constraints:

• `0 <= nums.length <= 105`
• `-109 <= nums[i] <= 109`

Solution:

Time complexity: O(N)

Space complexity: O(1)

--

--

# LeetCode — Number of Islands (Blind Curated 30)

Given an `m x n` 2D binary grid `grid` which represents a map of `'1'`s (land) and `'0'`s (water), return the number of islands.

An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

Example 1:

`Input: grid = [  ["1","1","1","1","0"],  ["1","1","0","1","0"],  ["1","1","0","0","0"],  ["0","0","0","0","0"]]Output: 1`

Example 2:

`Input: grid = [  ["1","1","0","0","0"],  ["1","1","0","0","0"],  ["0","0","1","0","0"],  ["0","0","0","1","1"]]Output: 3`

Constraints:

• `m == grid.length`
• `n == grid[i].length`
• `1 <= m, n <= 300`
• `grid[i][j]` is `'0'` or `'1'`.

Solution:

Time complexity: O(N²)

Space complexity: O(N)

--

--