The coding seems to be much more complex than those smart methods such as this one, but the idea behind is actually quite straightforward. Unfortunately, it is not as fast as the smart ones.
First, we divide the matrix into four quarters as shown below:
zone 1 zone 2
* * * *  * * * *
* * * *  * * * *
* * * *  * * * *
* * * *  * * * *

* * * *  * * * *
* * * *  * * * *
* * * *  * * * *
* * * *  * * * *
zone 3 zone 4
We then compare the element in the center of the matrix with the target. There are three possibilities:

center < target. In this case, we discard zone 1 because all elements in zone 1 are less than target.

center > target. In this case, we discard zone 4.

center == target. return true.
For time complexity, if the matrix is a square matrix of size nxn
, then for the worst case,
T(nxn) = 3T(n/2 x n/2)
which makes
T(nxn) = O(n^log3)
Code in Java:
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length;
if(m<1) return false;
int n = matrix[0].length;
return searchMatrix(matrix, new int[]{0,0}, new int[]{m1, n1}, target);
}
private boolean searchMatrix(int[][] matrix, int[] upperLeft, int[] lowerRight, int target) {
if(upperLeft[0]>lowerRight[0]  upperLeft[1]>lowerRight[1]
 lowerRight[0]>=matrix.length  lowerRight[1]>=matrix[0].length)
return false;
if(lowerRight[0]upperLeft[0]==0 && lowerRight[1]upperLeft[1]==0)
return matrix[upperLeft[0]][upperLeft[1]] == target;
int rowMid = (upperLeft[0] + lowerRight[0]) >> 1;
int colMid = (upperLeft[1] + lowerRight[1]) >> 1;
int diff = matrix[rowMid][colMid]  target;
if(diff > 0) {
return searchMatrix(matrix, upperLeft, new int[]{rowMid, colMid}, target)
 searchMatrix(matrix, new int[]{upperLeft[0],colMid+1}, new int[]{rowMid, lowerRight[1]}, target)
 searchMatrix(matrix, new int[]{rowMid+1,upperLeft[1]}, new int[]{lowerRight[0], colMid}, target);
}
else if(diff < 0) {
return searchMatrix(matrix, new int[]{upperLeft[0], colMid+1}, new int[]{rowMid, lowerRight[1]}, target)
 searchMatrix(matrix, new int[]{rowMid+1, upperLeft[1]}, new int[]{lowerRight[0], colMid}, target)
 searchMatrix(matrix, new int[]{rowMid+1, colMid+1}, lowerRight, target);
}
else return true;
}