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:**

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:**

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:**

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 = 2`

Output: [1,2,3,5]

**Example 2:**

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

Output: []

**Example 3:**

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

Output: [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)

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)

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: 1

Explanation: [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: 2

Explanation: 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: 0

Explanation: 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)**

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: 4

Explanation: 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)

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)