Question

我必须做一个算法，aprop，使用分而治之来计算列表中彼此更接近的几个点，我还要计算复杂性。

def aprop(a):
    longitudlista = len(a)
    if longitudlista <= 2:
        return a
    else:
        mig = longitudlista / 2
        pivot = (a[mig])

a= [1.2,2.9,3.1,4.0,5.7]

aprop(a)

现在我希望算法返回几个点，这些点具有使用数据透视表列表中所有元素的所有差异的最小差异。我怎样才能在代码中写出这个想法？

Answer 1

以下代码是分而治之计划的一般实施：

def divide_and_conquer(S, divide, combine): 
  if len(S) == 1: return S
  L, R = divide(S)
  A = divide_and_conquer(L, divide, combine)
  B = divide_and_conquer(R, divide, combine)
  return combine(A, B)

基于上述算法，您可以使用：

from operator import sub

def divide_and_conquer(S, combine=[]):
    if len(S) == 2:
       combine.append(S)
    else :
       L, R = S[:(len(S)/2)+1],S[len(S)/2:]
       A = divide_and_conquer(L)
       B = divide_and_conquer(R)
       result=[abs(sub(i,j)) for i,j in combine]
       return combine[result.index(min(result))]

a= [1.2,2.9,3.1,4.0,5.7]

print divide_and_conquer(a)
[2.9, 3.1]

Answer 2

对数组进行排序，并成对检查最小距离。

可以使用分而治之算法完成排序，例如O(nlog(n))时间内的merge_sort。

例如，你可以像这样搭载合并排序：

# For convenience of representation, assume pairs to be defined as 
# tuples of form ( no_1, no_2 )

def closest_pair(array):
    l = len(array)
    pivot = l/2

    if len(array) == 2:
        # Simply returns the pair
        return (array[0], array[1])

    if len(array) == 3:
        # Returns the pair which has the smallest distance amongst the 3C2 pairs
        return min(itertools.combinations(array, r = 2), key = lambda x : abs(x[1] - x[0]) )


    left_closest = closest_pair(array[:pivot])
    right_closest = closest_pair(array[pivot:])
    split_pair = (array[pivot-1], array[pivot]) # Just incase the split_pair is the closest

    return min(left_closest, right_closest, split_pair, key = lambda x : abs(x[1] - x[0]) )

对于您的阵列[1.2,2.9,3.1,4.0,5.7]

>>> closest_pair([1.2,2.9,3.1,4.0,5.7])
(2.9, 3.1)

旁注：

如果你不关心分而治之的实现，你可以简单地使用min使用密钥和itertools.combinations（就像上面针对组合步骤/ {{1等于3.）

len(array)

选中此项以了解更多信息：

itertools.combinations
min with a key parameter - 已针对>>> a = [1.2,2.9,3.1,4.0,5.7] >>> min(itertools.combinations(a, r = 2), key = lambda x : abs(x[1] - x[0]))) (2.9, 3.1)进行了解释，但同样适用于max。

希望这会有所帮助......

在列表中彼此更接近的几个点

2 个答案: