Maximum Number Of Points From Grid Queries - Leetcode Solution

Problem Statement:

You are given an empty 2D grid where each cell is represented as a letter or a digit. The grid is of size n × m.

You are allowed to perform n + m queries. Each query consists of selecting a row or a column of the grid and sorting the elements in it in non-decreasing order (in the case of letters, the sort order is alphabetical, whereas in the case of digits, it is numeric ascending order).

After performing n + m queries, you wish to select some subset of cells in the grid such that:

• The number of selected cells is even.
• Each selected cell is distinct.

What is the maximum number of cells that can be selected?

Solution:

Approach:

The problem can be solved using the following approach:

• We can represent each cell as a tuple containing the letter/digit and its position in the grid.
• Then, we can perform the sorting queries on the rows and columns separately.
• After each query, we update our tuples to reflect the new position of the cells.
• Then, we can use dynamic programming to find the maximum number of cells that can be selected.

Dynamic Programming:

We can define our dynamic programming state as follows: dp[i][j][p][q] = the maximum number of cells that can be selected using the first i rows, j columns, where the last selected cell is (p, q).

We can then use the following recurrence relation:

dp[i][j][p][q] = max(dp[i-1][j][p'][q] + (is_even(i-1) xor is_even(p')) + (is_even(j) xor is_even(q)),

                  dp[i][j-1][p][q'] + (is_even(i) xor is_even(p)) + (is_even(j-1) xor is_even(q')))

where is_even(x) returns 1 if x is even and 0 if x is odd.

This recurrence relation considers two cases:

• The last selected cell was from the i-th row. In this case, we can select any cell from the i-th row that is distinct from the last selected cell (p, q) and has an even index. We add (is_even(i-1) xor is_even(p')) to the score to ensure that we have selected an even number of cells.
• The last selected cell was from the j-th column. In this case, we can select any cell from the j-th column that is distinct from the last selected cell (p, q) and has an even index. We add (is_even(j-1) xor is_even(q')) to the score to ensure that we have selected an even number of cells.

The final answer is given by dp[n][m][0][0], which represents the maximum number of cells that can be selected using all the rows and columns.

Time Complexity:

• Sorting the rows and columns takes O(n log n) and O(m log m) time respectively.
• Each dynamic programming state takes O(nm) time to compute.
• Therefore, the total time complexity of the algorithm is O((n+m) nm log nm).

Space Complexity:

• We need O(nm) space to store our dynamic programming state.
• Therefore, the space complexity of the algorithm is O(nm).

Code:

1