GATE-CS-2015 (Set 2) Question 65

This question is a theoretical question about the complexity of a particular algorithm. The algorithm takes an input matrix of size m x n and searches for a specific element in the matrix. This algorithm first starts at the top right corner of the matrix, and then based on the comparison of the target element with the current element, it narrows down its search to either the left or the down direction.

The worst-case time complexity of this algorithm is O(m+n). This is because in the worst case scenario, the algorithm may have to traverse the entire row and column of the matrix. Specifically, if the target element is the smallest element in the matrix, the algorithm will have to traverse the entire first row before moving down to subsequent rows. Similarly, if the target element is the largest element in the matrix, the algorithm will have to traverse the entire last column before moving left to subsequent columns.

In order to understand this algorithm better, we can take a look at the code snippet below:

def search_matrix(matrix, target):
    m = len(matrix)
    n = len(matrix[0])
    i = 0
    j = n - 1
    
    while i < m and j >= 0:
        if matrix[i][j] == target:
            return True
        elif matrix[i][j] > target:
            j -= 1
        else:
            i += 1
            
    return False

Here, matrix is the input matrix, and target is the element that we are searching for. The algorithm initializes two pointers, i and j, to the top right corner of the matrix. It then iteratively compares the target element with the current element at position (i, j). If the target element is greater than the current element, it means that the target element cannot be in the current row, so the algorithm moves down to the next row by incrementing i. If the target element is smaller than the current element, it means that the target element cannot be in the current column, so the algorithm moves left to the previous column by decrementing j. The algorithm continues to move either left or down until it finds the target element, or until it reaches the bottom left corner of the matrix.

Overall, this algorithm provides a fast and efficient way to search for elements in a matrix, with a worst-case time complexity of O(m+n).