只遍历数组中能被当前元素整除的元素答案

【问题标题】：Traverse only those elements which are divisible by the current element in an array只遍历数组中能被当前元素整除的元素
【发布时间】：2019-10-06 06:03:57
【问题描述】：

考虑一个数组：10 2 4 14 1 7 遍历每个有效 i 的输入数组，我必须找到所有可被第 i 个元素整除的元素。所以，首先我必须找到所有大于第 i 个元素的元素。

示例输出：

10 -> null
2 -> 10
4 -> 10
14 -> null
1 -> 14,4,2,10
7 -> 14,10

我的方法：我正在考虑创建一个二叉树，该二叉树将为数组中的每个有效插入执行 log n 操作，该数组将重新构造二叉树，其中最小元素为根，左侧元素较小，右侧元素较大。现在我只需要遍历插入元素的右子树并检查哪些元素可以被第 i 个元素整除。这是一种非常昂贵的方法，但比蛮力更好。

谁能帮助找到一个更有效的最佳解决方案？

【问题讨论】：

你的问题有点含糊。该函数是否应该将数组作为输入，然后返回一个列表列表，如[None, [10], [10], None, [14,4,2,10], [14,10]]。还是它需要数组和索引并返回元素列表 > array[i]？
不，我写这个是因为它很容易理解。实际输出应该是一个整数，它是第 i 个元素可以划分的最大元素数。
所以调用函数看起来像function(array, index)，它会返回索引 0...(i-1) 处的值的数量，这些值可以被索引处的值整除 i？您是否希望使用相同的数组但不同的索引多次调用该函数？
是的，但完整的方法应该是 O(nlogn) 而不是 O(n^2)

标签： python arrays algorithm c++14 binary-tree

【解决方案1】：

建立一个递减运行列表

在扫描列表时，如果当前元素是

示例数组变为[[10, 2], [4], [14, 1], [7]]。

然后扫描每次运行并对大于 element[i] 的元素进行处理就很简单了。

这是处理输入数组并返回列表列表的示例代码。

def bigger_so_far(seq):
    results = []
    runs = []

    for element in seq:
        if runs:
            if element > runs[-1][-1]:
                runs.append([])
            runs[-1].append(element)

        else:
            runs.append([element])

        result = []
        for run in runs:
            for j in run:
                if j <= element:
                    break
                result.append(j)

        results.append(result)

    print(runs)

    return results

示例运行：

bigger_so_far([10, 2, 4, 14, 1, 7]) #=> [[], [10], [10], [], [10, 2, 4, 14], [10, 14]]

【讨论】：

【解决方案2】：

最坏情况的时间复杂度不会比 O(n^2) 好。因此，蛮力解决方案就可以了。

考虑以下输入（这也是最坏的情况）：

arr = [1, 1, 1,  ..., 1, 1]

对于arr[0] = 1，答案中会有0 elements。

对于arr[1] = 1，答案中会有1 element。

...

对于arr[n - 2] = 1，答案中会有n - 2 elements。

对于arr[n - 1] = 1，答案中会有n - 1 elements。

因此，答案中的元素总数为：

0 + 1 + 2 + ... + (n - 1)
= ((n - 1) * n) / 2
= O(n^2)

如果您只是想找到the number of elements and not the actual elements，那么确实有更好的解决方案。

【讨论】：

先生，我已将问题编辑为原始问题。