Question

设计一种算法，输出A中小于或等于x的条目数。您的算法应该在O（n）时间内运行。

例如，在下面的数组中，如果我的目标是＆＃39; 5＆＃39;然后我会返回2 b / c 1和3更小。

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

我用下面的代码给了它一个接近工作的代码，我认为它是O（n）......我看到的问题是我是否在我的数组中没有＃我不确定我是否正在返回正确的值？

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))

检查上面的Count和简单矩阵，看看soln是否有效〜

Answer 1

如果列和行都按升序排序，则对于任何给定的边界值，某些楼梯线确实存在。它将矩阵分为两部分 - 更高（和相等）和低于边界值。该行总是左右移动（如果遍历从右上角开始）。

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

因此，从右上角扫描，在右边或上边缘找到该线的起始单元格，然后沿着该线，计算留给它的元素。

复杂性是线性的，因为线永远不会回头。

P.P.S。我希望你能用给定的线索编写代码

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

正如我的评论中提到的，对于大多数矩阵，O（n）中的问题无法解决。其他一些想法：

为什么要向下计算j？
i和j永远不会成为n

这是O（n）中的解决方案，可能满足您的需求。

以下是改编的代码：

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

以上建议的两个答案都将导致O（n ^ 2）。在最坏的情况下，该算法将检查矩阵中的所有n ^ 2个元素。

在O（n）中排序矩阵中找到小于目标的＃元素的算法？

3 个答案: