在 O(n) 中的已排序矩阵中查找小于目标的 # 个元素的算法？

Question

Design an algorithm that outputs the number of entries in A that are smaller than or equal to x. Your algorithm should run in O(n) time.

For example in the array below if my target was '5' then I would return 2 b/c 1 and 3 are smaller.

[1, 3,  5]
[2, 6,  9]
[3, 6, 10]

I gave it a shot with the code below which is close to working and I think it's O(n) ... the problem I see is if I don't have the # in my array I am not sure if I am returning the right value?

def findLessX(m,n,x):
    i = 0
    j = n-1

    while (i < n and j >= 0):
        if i == n or j == n:
            print("n not found")
            return (i+1)*(j+1)-1


        if (m[i][j] == x):
            print(" n Found at ", i , " ", j)
            return (i+1)*(j+1)-1
        elif (m[i][j] > x):
            print(" Moving left one column")
            j = j - 1
        elif (m[i][j] < x):
            print(" Moving down one row")
            i = i + 1

    print(" n Element not found so return max")
    return (i)*(j+1)

# Driver code
x = 5
n = 3
m = [ [1, 3, 5],
      [2, 6, 9],
      [3, 6, 9]]
print("Count=", findLessX(m, n, x))

Inspect the Count and simple matrix above to see if soln works ~

Answer 1

If both columns and rows are sorted ascending, then for any given border value some stairs line does exist. It divides matrix into two parts - higher (and equal) and lower than border value. That line always goes left and down (if traversal starts from top right corner).

[1, 3,  |5]
    ____|
[2,| 6,  9]
[3,| 6, 10]

So scan from top right corner, find starting cell for that line on the right or top edge, then follow the line, counting elements being left to it.

Complexity is linear, because line never turns back.

PPS I hoped that you could write code with given clues

def countLessX(m,n,x):
    col = n-1
    count  = 0

    for row in range(n):
        while (col >= 0) and (m[row] [col] >= x):
            col = col - 1
        count = count + col + 1
    if col < 0:   #early stop for loop
        break
    return count

# Driver code
n = 3
m = [ [1, 3, 5],
      [2, 6, 9],
      [3, 6, 9]]
for x in range(11):
   print("x=", x, "Count=", countLessX(m, n, x))

x= 0 Count= 0
x= 1 Count= 0
x= 2 Count= 1
x= 3 Count= 2
x= 4 Count= 4
x= 5 Count= 4
x= 6 Count= 5
x= 7 Count= 7
x= 8 Count= 7
x= 9 Count= 7
x= 10 Count= 9

Answer 2

As mentioned in my comment your problem is not solveable in O(n) for most matrices. Some other thoughts:

• Why count j downwards?
• i and j can never become n

Here is a solution in O(n) that perhaps fullfills your needs.

Here is the adapted code:

def findLessX(m,n,x):
  i = 0
  j = 0

  while True:
    if i+1<n and m[i+1][j]<x:
      i=i+1
    elif j+1<n and m[i][j+1]<x:
      j=j+1
    else:
      print("n found at ", i+1 , " ", j+1, "or element not found so return max")
      return (i+1)*(j+1)

Answer 3

Both answers suggested above will result in O(n^2). In worst case, the algorithms will inspect all n^2 elements in the matrix.