Java 确定数据集中的任意3个整数是否在O（n^2）时间内总和为目标值

所以我在做这个项目，它让我难堪

我们有两个整数数组。第一个数组是我们将使用的项目集，第二个数组是一组目标值

从第一个数组中，我应该找到第二个数组中是否有任何3个数字总和为目标值之一。因此，对于第二个数组中的每个目标值，我检查是否有任何3个数字与该目标相加。如果有，我只打印“是”或“否”

现在，我知道如何在O（n^3）时间内完成这项工作，但项目需要O（n^2），我不知道如何完成这项工作-主要是因为我还必须循环遍历目标值数组，并对每个目标值进行检查

我得到了一个使用图形、树、BFS的提示，但即使如此，我仍在努力寻找如何做到这一点

有人知道我应该使用什么样的数据结构，或者我应该如何处理这个问题吗？谢谢大家!

---

任务： 您将编写一个java程序 从文件中读取一组整数数据， 将该数据存储到数据结构中，以及 重复确定数据集中的任意3项总和是否为目标值。 O（n^2）

第一个数组示例：15 82 22 36 29 11 31 4 31 第二个数组示例：1199-257297393 示例输出： 119是的 9号 -2号 57是的 29号 73是的 93否

不确定该

O（n^2）

是用于每次查找还是用于整个系统。你可能想得到澄清。这就是说，如果您想看一看，这里有一个非常有效的潜在实现（至少小于

O（n^3）

，不确定确切的值）。它使用了一个HashMap，所以它首先加载所有的计算，然后使任何后续的查找都非常有效

import java.util.Arrays;
import java.util.HashMap;

public class Permutations
{
  public static void main(String[] args)
  {
    int[] array1 = {15, 82, 22, 36, 29, 11, 31, 4, 31};
    int[] array2 = {119, 9, -2, 57, 29, 73, 93};
    
    HashMap<Integer, Integer[]> map = new HashMap<Integer, Integer[]>();
    
    for(int i = 0; i < array1.length; i++)
    {
      for(int j = i + 1; j < array1.length; j++)
      {
        for(int k = j + 1; k < array1.length; k++)
        {
          Integer value = array1[i] + array1[j] + array1[k];
          Integer[] set = {array1[i], array1[j], array1[k]};
          map.put(value, set);
        }
      }
    }
    
    for(int i = 0; i < array2.length; i++)
    {
      if(map.containsKey(array2[i]))
        System.out.print(array2[i] + " YES " + Arrays.toString(map.get(array2[i])));
      else
        System.out.print(array2[i] + " NO");
      
      if(i != array2.length - 1)
        System.out.print(", ");
    }
  }
}

导入java.util.array；
导入java.util.HashMap；
公共类置换
{
公共静态void main（字符串[]args）
{
int[]数组1={15,82,22,36,29,11,31,4,31}；
int[]array2={119,9，-2,57,29,73,93}；
HashMap=newHashMap（）；
for（int i=0；i

您可以在哈希映射中存储两个整数的所有和。当您需要找到具有给定和的三个整数时，对第一个整数遍历数组，并对其他两个整数询问哈希映射。请注意，这两个整数必须在第一个整数的右边，因此您应该将和的最右边位置存储为值

import java.util.HashMap;

public class Main {
  public static void main(String[] args) {
    int[] firstArray = {15, 82, 22, 36, 29, 11, 31, 4, 31};
    int[] secondArray = {119, 9, -2, 57, 29, 73, 93};

    HashMap<Integer, Integer> fromPosition = new HashMap<>();
    for (int i = 0; i < firstArray.length; i++) {
      for (int j = i + 1; j < firstArray.length; j++) {
        fromPosition.put(firstArray[i] + firstArray[j], i);
      }
    }

    for (int sum : secondArray) {
      boolean yes = false;
      for (int firstPosition = 0; firstPosition < firstArray.length; firstPosition++) {
        Integer position = fromPosition.get(sum - firstArray[firstPosition]);
        if (position != null && position > firstPosition) {
          yes = true;
          break;
        }
      }
      System.out.println(sum + (yes ? " YES" : " NO"));
    }
  }
}

import java.util.HashMap；
公共班机{
公共静态void main（字符串[]args）{
int[]firstArray={15,82,22,36,29,11,31,4,31}；
int[]secondArray={119,9，-2,57,29,73,93}；
HashMap fromPosition=新HashMap（）；
for（int i=0；ifirstPosition）{
是=正确；
打破
}
}
System.out.println（总和+（是？“是”：“否”）；
}
}
}

---

这需要O（n^2）时间和O（n^2）内存（如果两个数组都有O（n）长度）。

对此表示歉意，但对整个系统来说，应该是O（n^2）。另外，我最近收到的一个更大的提示是，应该首先对它进行排序，然后在一个更大的for循环（非嵌套）中使用两个for循环，即for（…）{for（…）{}for（…）{}}我相信外部for循环是用于迭代目标值，而内部的是用来检查3sum是否存在。到目前为止你都做了些什么？分享你的代码。