Question

假设你有一个未排序的数组，你将如何找到2个相等的元素，使它们在数组中最远。对于例如8 7 3 4 7 5 3 9 3 7 9 0，ans将为7(9) - 7(1) = 8。我想到了以下

initialise max = 0
using hashing, store the elements along with its index
whenever there is a collision, compare the current index with the hashed one
if it is greater, set max = current index - hashed one and copy element along with index to some other location.

及时运行 - O（n）和空间 - O（n）。它是否正确？有没有更好的解决方案。

Answer 1

O（n）运行时间和O（n）空间似乎是最佳的AFAIK。

这是python实现：

#!/usr/bin/python
hashindex = {}

l = [8,7,3,4,7,5,3,9,3,7,9,0]

max_diff = 0
value = 0

for i in range(len(l)):
    indices = hashindex.get(l[i], None)
    if indices:
        hashindex[l[i]] = (indices[0], i)
    else:
        hashindex[l[i]] = (i, i)
    diff = hashindex[l[i]][1] - hashindex[l[i]][0]
    if diff > max_diff:
        max_diff = diff
        value = l[i]

print max_diff, value

Answer 2

我非常怀疑这是“正确的”答案，但如果我在工作中遇到这个问题，我会按照按值排序然后按索引进行快速排序。然后我将遍历我的有序数组，并为每个值，抓住第一个和最后一个索引。这将成为候选人最大距离。每当我遇到一个新值时，我会将它与我当前的最大距离进行比较，然后只存储最大值。这样，运行时间就是

sort + walk = total N Log N + N = N Log N

例：无序数组中的值： 1,2,3,1,5,3,3,3

1,1,2,3,3,3,3,5 =值 0,3,1,2,5,6,7,4 =索引

1 =最大3-0 = 3

2's = x

3 =最大值7-2 = 5

最多5

请记住，这可能不是教科书的答案，但它仍然可以在N Log N中运行，因此我会在工作中使用它，对于百万元素以下的任何内容都没有任何疑虑。

你有没有想过这个问题的任何其他潜在答案？如何改进这个？

Answer 3

以下是我对最佳解决方案的看法：

由于两个元素的距离最远，我会创建一个循环来查看数组的开头，同时在数组的末尾，并向内看，第一个相应的元素他们发现，将是最远的。

例如：

8 7 3 4 7 5 3 9 3 7 9 0

First look at 8, 0, and store them in set A, and in set B respectively.
Look at 7, 9, and store them in the same sets fashion.
Look at 3, 7, and same as above. Now this 7 is already in the opposite set, A. 
Therefore they must be the farthest apart. Just calculate the distance between the the 7 elements.

现在我考虑一下，你只需要做一些检查，以确保最远的元素现在在一个集合本身。

因此，如果任何一组具有所有元素的1/3，则还必须开始检查最大距离是否不在集合本身内。

Answer 4

我的Java解决方案： int [] testArr = {1,2,3,5,1,7,5,4,3,1,2,3,2,3}; int maxLen = 0; int minidx = 0; int maxidx = 0; int numVal = testArr [0]; int counter = 0; //只是检查它进入下面的条件

的次数

for (int ii=0;ii<testArr.length-maxidx;ii++) {

    for (int jj=testArr.length-1;jj>=ii+maxidx;jj--){

        if(testArr[ii]==testArr[jj] /*&& maxLen<(jj-ii)*/){

            System.out.println(counter++);

            minidx = ii;
            maxidx = jj;
            maxLen = jj-ii;
            numVal = testArr[ii];

            break;

        }
    }
}

System.out.println(maxLen +" "+minidx+" "+maxidx+" "+numVal);

Answer 5

及时运行 - O（n）和空间 - O（n）。这是对的吗？

是

是否有更好的解决方案。

我非常怀疑。

JavaScript实现：

function furthest(a) {
  const first= {};

  return a.reduce((longest, elt, idx) => {
    if (!(elt in first)) first[elt] = idx;
    return Math.max(longest, idx - first[elt]);
  }, Infinity);

}

Answer 6

obj-c中的解决方案。应该是O（N）。只需一次通过阵列。

ValueError: malformed string

数组中最相等的元素

6 个答案: