## Understanding Multidimensional Array

Multidimensional arrays play a significant role in problem-solving, especially in computer programming and data manipulation tasks. They provide a way to organize and store data in a structured manner with multiple dimensions. Each dimension represents a different level of indexing, allowing you to access and manipulate data using various combinations of indices.

From a previous article, which gives a basic introduction to arrays and multidimensional arrays in general, It became intriguing to write a more hands-on article on multidimensional arrays because of their complexity compared to a one-dimensional array. To help us better understand this concept, we will dissect a problem involving the search for a value in a 2D matrix with an interesting twist.

Brace yourselves, for we're about to unravel the journey of developing an efficient algorithm to search through a multidimensional array aka, matrix.

## The Challenge Unveiled: Navigating the 2D Matrix

Our challenge will begin with a 2D matrix, an array of arrays if you will. But this matrix comes with a set of intriguing rules: each row is arranged in ascending order, and the first element of each row is greater than the last element of the previous row. This peculiar arrangement has a sort of orderly elegance to it, like climbing up a ladder of numbers.

```
# Example 2D matrix
matrix = [
[1, 3, 5],
[7, 9, 11],
[13, 15, 17]
]
```

The task at hand is to design an algorithm that can efficiently locate a specific value within this matrix. While the matrix's row-by-row sorting provides a hint, the fact that it's split into different rows adds an extra layer of complexity to the problem.

## Glimpses of Binary Search: Our First Approach

As seasoned problem solvers might recognize, a sorted array often calls for the employment of the binary search technique.

If you are not familiar with binary search, let's talk about this super useful trick. Imagine you have a long list of numbers in order, and you want to find a particular number. Instead of checking each number one by one, you can split the list in half and decide whether the number you're looking for is in the left half or the right half. You keep cutting the possibilities in half until you find your target. You do the continuous cutting using a while loop. This trick is like a treasure hunt that gets quicker and quicker as you go.

Binary search:

```
def binary_search(arr, target):
left, right = 0, len(arr) - 1
while left <= right:
mid = left + (right - left) // 2
if arr[mid] == target:
return True
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return False
```

Left and right represent the starting point and the ending point of the array respectively. The loop runs as long as the left is not greater than the right. We begin our search from the middle(mid) because we want to disregard half of the array if our target cannot be in it. We do this by comparing our target with the middle item, If our target is greater than the middle item, then we know our target cannot be found in the first half, and vice versa, so we move our starting or ending point as the case may be.

We can then use the binary search helper above for each row of our matrix:

```
def search_matrix(matrix, target):
rows, cols = len(matrix), len(matrix[0])
for row in range(rows):
if binary_search(matrix[row], target):
return True
return False
```

This approach involves conducting a binary search on each row. By treating each row as an independent, sorted array, we embark on an exploration of every row. If we find it in any row, we can celebrate our success. But if we search through all the rows and don't find our number, we can be sure it's not in the grid. This strategy results in an M x log N solution, where M represents the number of rows and N stands for the number of columns.

## Scrutinizing the Approach: A Deeper Dive

Visualizing each row as an isolated entity undergoing its binary search might appear straightforward. Yet, the observant eye discerns an opportunity for further optimization. After all, isn't there a way to exploit the matrix's inherent structure?

In the quest for optimization, a promising prospect will be to imagine that the matrix was flattened into a single array. So Instead of looking at each row separately, we can imagine that all the rows are stuck together in one long line. Then, we can use our binary search trick just like we would on a single row of numbers, yielding a logarithmic solution.

## Unveiling the Clever Solution: A New Perspective

With this new way of thinking, the puzzle starts to make sense. But we need to figure out where the numbers from each row would be in our long line, We can do this by calculating a midpoint and then using **division and the modulo operation** to figure out which row and column the midpoint corresponds to.

Flattened array analogy:

```
def search_matrix(matrix, target):
rows, cols = len(matrix), len(matrix[0])
left, right = 0, rows * cols - 1
while left <= right:
#calculate the middlepoint within the left and right
mid = left + (right - left) // 2
#the division and modulus operator
mid_value = matrix[mid // cols][mid % cols]
if mid_value == target:
return True
elif mid_value < target:
left = mid + 1
else:
right = mid - 1
return False
```

We know that to treat the matrix as a single-line array, what we need to do is to get the startpoint(left) and the endpoint(right). The endpoint in this case will be the length of the row "and" column put together. We know that "and" in mathematics is multiplication, therefore the endpoint of the matrix will be "row * col". The index starts at zero, so we always have to remove 1 from the endpoint.

Continuing with our analogy of a flattened array in our case: [ 1, 3, 5, 7, 9, 11, 13, 15, 17 ] Calculating the first midpoint(mid) will give us 5. But there is no such index as 5 in our matrix, the partitioned nature of the matrix complicates matters. We can only find value by a combination of row and column index. For instance, to print out 11, which is on row 2 column 3, we use **matrix[1][2]** and not just index 5, even though in a flattened array, 11 will be at index 5.

That is why we have to convert 5 into the index of the row and column using the division and the modulo operation. We can use the length of the row **OR** the length of the column for the **division and modulo operation** depending on if the matrix is a row-major or column-major, i.e., sorted by row or column. We will stick to using the length of the column here because ours is sorted by column. **5➗3=1** while **5%3=2**. The division value being our row, and the modulo value being our column gives us the value corresponding to the midpoint value **matrix[1][2]**. Then we can do our comparison and repeat the loop until the target is found.

What we end up with is a snappy algorithm that zooms through the matrix with style. It's like a dance between binary search and some math magic, resulting in a solution that's both efficient and, dare we say, pretty darn cool.

Even though nothing much has changed and we are still using our binary search, this innovative perspective transforms the problem into a logarithmic M times N solution.

## The Road Less Traveled: Problem-Solving Insights

And there you have it! We've tackled the challenge of searching for a number in a special grid. We learned about binary search – a powerful tool for finding things quickly in sorted lists. We explored how to use it on each row and even figured out a way to make our search even faster by treating all the rows like they're in a single line. The process of dissecting, analyzing, and iterating unveils the hidden beauty in the realm of code. In the end, the satisfaction of unraveling such enigmas lingers as a testament to the boundless potential of human creativity and computational prowess. Now you can carry this solution idea into many matrix/multidimensional array problems.

Remember, learning about these cool techniques is like adding tools to your problem-solving toolbox. The world of arrays and matrices might seem complex, but with a little bit of creativity and some clever tricks, you can conquer any challenge that comes your way. So keep exploring, keep practicing, and keep having fun solving those amazing coding problems!