Question

我们需要在数组中找到最大元素，该元素也等于同一数组中两个元素的乘积。例如[2,3,6,8]，这里6 = 2 * 3所以答案是6。

我的方法是对数组进行排序，然后使用双指针方法检查每个元素是否存在产品。这是o（nlog（n））+ O（n ^ 2）= O（n ^ 2）方法。有更快的方法吗？

Answer 1

如果允许使用O（M）内存M = A [i]中的最大数量，则有一个更好的O（n * sqrt（n））解决方案使用大小为M的数组来标记每个数字，同时从较小的数字到较大的数字遍历它们。对于每个数字，尝试其所有因素，看看它们是否已经存在于数组映射中。

以下是伪代码：

#define M 1000000
int array_map[M+2];
int ans = -1;
sort(A,A+n);
for(i=0;i<n;i++) {
  for(j=1;j<=sqrt(A[i]);j++) {
    int num1 = j;
    if(A[i]%num1==0) {
      int num2 = A[i]/num1;
      if(array_map[num1] && array_map[num2]) {
        if(num1==num2) {
            if(array_map[num1]>=2) ans = A[i];
        } else {
          ans = A[i];
        }
      }
    }
  }
  array_map[A[i]]++;
}

如果您知道如何在log（M）中找到所有可能的因子，这就变得更好O（n * logM）。你必须使用筛子和回溯

Answer 2

@JerryGoyal的解决方案是正确的。但是，我认为如果不使用B指针，我们可以进一步优化，如果arr [c]可被arr [a]整除，我们使用二分搜索来找到产品的其他因子。这是他的代码的修改：

for(c=n-1;(c>1)&& (max==-1);c--){       // loop through C
    for(a=0;(a<c-1)&&(max==-1);a++){    // loop through A
        if(arr[c]%arr[a]==0)            // If arr[c] is divisible by arr[a]
        {
            if(binary_search(a+1, c-1, (arr[c]/arr[a]))) //#include<algorithm>
            {
                max = arr[c];          // if the other factor x of arr[c]  is also in the array such that arr[c] = arr[a] * x
                break;
            }
        }
    }
}

我会对他的解决方案发表评论，遗憾的是我缺乏这样做的声誉。

Answer 3

试试这个。用c ++编写

#include <vector>
#include <algorithm>

using namespace std;

int MaxElement(vector< int > Input)
{
    sort(Input.begin(), Input.end());
    int LargestElementOfInput = 0;
    int i = 0;
    while (i < Input.size() - 1)
    {
        if (LargestElementOfInput == Input[Input.size() - (i + 1)])
        {
            i++;
            continue;
        }

        else
        {
            if (Input[i] != 0)
            {
                LargestElementOfInput = Input[Input.size() - (i + 1)];
                int AllowedValue = LargestElementOfInput / Input[i];
                int j = 0;

                while (j < Input.size())
                {
                    if (Input[j] > AllowedValue)
                        break;
                    else if (j == i)
                    {
                        j++;
                        continue;
                    }
                    else
                    {
                        int Product = Input[i] * Input[j++];
                        if (Product == LargestElementOfInput)
                            return Product;
                    }
                }
            }

            i++;
        }
    }

    return -1;
}

Answer 4

对阵列进行排序后，您可以使用它，如下所示。

我可以看到一个改进 - 因为你想找到符合标准的最大元素，

从数组最右边的元素开始。（8）
将其与数组的第一个元素分开。（8/2 = 4）。
现在继续双指针逼近，直到第二个指针处的元素小于上面步骤2的值或找到匹配。（即，直到第二指针值<4或找到匹配）。
如果找到匹配项，那么您将获得最大元素。
否则，继续循环使用数组中的下一个最高元素。（6）。

Answer 5

高效解决方案：

2 3 8 6

对数组进行排序
保留3个指针C，B和A.
保持C在最后，A在0指数，B在第1指数。
使用指针A和B遍历数组直到C并检查A * B = C是否存在。
如果它存在，那么C就是你的答案。
否则，将C移回并再次遍历，将A保持为0，将B保持在第1个索引。

不断重复这个，直到你得到总和或C达到第一个指数。

以下是完整的解决方案：

int arr[] = new int[]{2, 3, 8, 6};
Arrays.sort(arr);

        int n=arr.length;
        int a,b,c,prod,max=-1;

        for(c=n-1;(c>1)&& (max==-1);c--){       // loop through C
            for(a=0;(a<c-1)&&(max==-1);a++){    // loop through A
                for(b=a+1;b<c;b++){             // loop through B
                    prod=arr[a]*arr[b];
                    if(prod==arr[c]){
                         System.out.println("A: "+arr[a]+" B: "+arr[b]);
                        max=arr[c];
                        break;
                    }
                    if(prod>arr[c]){ // no need to go further
                        break;
                    }
                }
            }
        }

System.out.println(max);

Answer 6

我提出了以下解决方案，其中我使用一个数组列表，并遵循一个公式：

 divisor(a or b) X quotient(b or a) = dividend(c)

对数组进行排序。
将数组放入Collection Col.（例如，具有更快查找，并维护插入顺序）
有2个指针a，c。
最后保持c，然后是0。
尝试遵循（除数（a或b）X商（b或a）=被除数（c））。
检查a是否是c的除数，如果是，则检查col中的b（a
如果a是除数且列表有b，那么c就是答案。否则增加1，按照步骤5,6直到c-1。
如果未找到max，则降低c index，并按照步骤4和5进行操作。

Answer 7

检查此C＃解决方案：

- 遍历每个元素，

-loop并将每个元素与其他元素相乘，

- 如果产品存在于数组中并且是最大

，则验证

private static int GetGreatest(int[] input)
    {
        int max = 0;        
        int p = 0; //product of pairs
         //loop through the input array
        for (int i = 0; i < input.Length; i++)
        {

            for (int j = i + 1; j < input.Length; j++)
            {
                p = input[i] * input[j];
                if (p > max && Array.IndexOf(input, p) != -1)
                {
                    max = p;
                }
            }
        }

        return max;
    }

时间复杂度O（n ^ 2）

数组中的最大元素，等于数组中两个元素的乘积

7 个答案: