Fatal编程技术网
  • arrays/
  • Arrays 给定两个数组和一个上限，获取索引对的最有效方法是什么？对于索引对，求和最大且低于上限？

Arrays 给定两个数组和一个上限，获取索引对的最有效方法是什么？对于索引对，求和最大且低于上限？

arrays algorithm

Arrays 给定两个数组和一个上限，获取索引对的最有效方法是什么？对于索引对，求和最大且低于上限？,arrays,algorithm,Arrays,Algorithm,给定两个数组A和B以及一个上限k，计算索引对（i，j）的最有效方法是什么 s = A[i] + B[j] s = max(A[a] + B[b]) for a = 0, 1, 2, .. , len(A)-1 and b = 0, 1, 2, .. , len(B)-1 and s < k s=A[i]+B[j] s=最大值（A[A]+B[B]），对于A=0,1,2，len（A）-1和b=0,1,2，len（B）-1 和 s-1和k>A[i]+B[j]>s_max： s_max=A[i

给定两个数组A和B以及一个上限k，计算索引对（i，j）的最有效方法是什么

s = A[i] + B[j]

s = max(A[a] + B[b]) for a = 0, 1, 2, .. , len(A)-1 and b = 0, 1, 2, .. , len(B)-1
and
s < k

s=A[i]+B[j]
s=最大值（A[A]+B[B]），对于A=0,1,2，len（A）-1和b=0,1,2，len（B）-1
和
s
比如说,

Given, 
A = [9,2,5]
B = [2,1,6]
k = 5

we get,
s = 2 + 2 = 4 < 5
and hence,
i = 1 and j = 0

给定，
A=[9,2,5]
B=[2,1,6]
k=5
我们得到，
s=2+2=4<5
因此，
i=1和j=0
所以输出应该是（1,0）

一个直接的方法将循环通过A和B的所有元素，但这将使最坏情况下的时间复杂度为O（nm），其中n=len（A）和m=len（B）

有更好的方法解决这个问题吗？

您可以对a和B使用排序。然后，您可以在>=k时使用提前休息。下面的函数返回所有p 
def sum小于（A，B，k）：
i_max=-1
j_max=-1
s_max=-np.inf
对于枚举（a）中的i，a：
如果a+B[0]>=k：
打破
对于枚举（b）中的j，b：
如果a+b>=k：
打破
如果a+b>s_max：
s_max=a+b
i_max=i
j_max=j
返回i_max，j_max
A.排序（）
B.排序（）
i、 j=总和小于（A，B，k）
我也为Saurab的建议编写了代码，相对于列表中的内容，这对于大k来说要快得多。然而，根据一些示例运行，对于较短的列表或较小的k，两个for循环的速度更快

def sum小于（A，B，k）：
i_max=j_max=-1
s_max=-np.inf
对于枚举（a）中的i，a：
j=二等分（B，k-a-1）
如果len（B）>j>-1和k>A[i]+B[j]>s_max：
s_max=A[i]+B[j]
i_max=i
j_max=j
返回i_max，j_max
B.排序（）
i、 j=总和小于（A，B，k）
您可以对A和B使用排序。然后您可以在>=k时使用提前休息。下面的函数返回所有p 
def sum小于（A，B，k）：
i_max=-1
j_max=-1
s_max=-np.inf
对于枚举（a）中的i，a：
如果a+B[0]>=k：
打破
对于枚举（b）中的j，b：
如果a+b>=k：
打破
如果a+b>s_max：
s_max=a+b
i_max=i
j_max=j
返回i_max，j_max
A.排序（）
B.排序（）
i、 j=总和小于（A，B，k）
我也为Saurab的建议编写了代码，相对于列表中的内容，这对于大k来说要快得多。然而，根据一些示例运行，对于较短的列表或较小的k，两个for循环的速度更快

def sum小于（A，B，k）：
i_max=j_max=-1
s_max=-np.inf
对于枚举（a）中的i，a：
j=二等分（B，k-a-1）
如果len（B）>j>-1和k>A[i]+B[j]>s_max：
s_max=A[i]+B[j]
i_max=i
j_max=j
返回i_max，j_max
B.排序（）
i、 j=总和小于（A，B，k）
这类问题可以通过对其中一个数组进行排序来解决

一种方法是：：

  • 制作一个元组数组
    temp
    ，这样每个元组都是
    （值，索引）
    ，其中
    值
    是
    B
    的项，
    索引
    是其在B    中对应的
    索引
  • 现在，根据元组的第一项，即值，对这个临时数组进行排序
  • 迭代数组
    A
    并使用
    二进制搜索
    在临时数组中查找
    K-A[i]
    的
    下限。让它位于索引
    j
  • 现在有两种可能性，要么
    A[i]+temp[j][0]>=K
    要么
  • 如果大于
    K
    ，则检查
    j-1
    是否存在，如果可能，更新
    currentMaximum
    ，因为这对可以是max，同时小于K，因为我们发现了下限
  • 如果小于K，则尽可能更新当前最大值
    • 如果您需要索引，而不是每次更新
    currentMaximum
    ，请存储
    i
    和
    j
    。

    通过这种方式，您可以找到对的最大和，使其小于数组B中给定的原始索引的K

    若元素的顺序和than无关，只需对B排序，并对B执行相同的步骤，而不是对temp

    时间复杂性 对于排序=O（len（B）*Log（len（B））
    对于遍历A并在B=O（len（A）*Log（len（B）），即O（nlog（n））上进行二进制搜索，可以通过对其中一个数组排序来解决此类问题

    一种方法是：：

  • 制作一个元组数组
    temp
    ，这样每个元组都是
    （值，索引）
    ，其中
    值
    是
    B
    的项，
    索引
    是其在B    中对应的
    索引
  • 现在，根据元组的第一项，即值，对这个临时数组进行排序
  • 迭代数组
    A
    并使用
    二进制搜索
    在临时数组中查找
    K-A[i]
    的
    下限。让它位于索引
    j
  • 现在有两种可能性，要么
    A[i]+temp[j][0]>=K
    要么
  • 如果大于
    K
    ，则检查
    j-1
    是否存在，并在可能的情况下更新
    currentMaximum
    ，因为