给定一个由N 个整数和一个整数K组成的数组arr[] ，任务是打印所有可能的唯一四元组(arr[i], arr[j], arr[k], arr[l])，其总和为K，例如他们所有的指数都是不同的。
例子：
Input: arr[] = {1, 0, -1, 0, -2, 2}, K = 0
Output:
-2 -1 1 2
-2 0 0 2
-1 0 0 1
Explanation:
Below are the quadruplets whose sum is K (= 0):
- {-2, -1, 1, 2}
- {-2, 0, 0, 2}
- {-1, 0, 0, 1}
Input: arr[] = {1, 2, 3, -1}, target = 5
Output:
1 2 3 -1
朴素的方法：最简单的方法是从给定的数组arr[]生成所有可能的四元组，如果四元组的元素总和为K ，则将当前四元组插入 HashSet 中以避免重复四元组的计数。检查所有四元组后，打印存储在 HashSet 中的所有四元组。
时间复杂度： O(N 4 )
辅助空间： O(N 4 )
高效的方法：上述方法也可以通过使用生成给定数组的所有可能对的想法来优化。按照给定的步骤解决问题：
- 初始化一个 HashMap，比如存储所有可能的四元组的ans 。
- 初始化一个 HashMap，比如说M ，它存储给定数组的所有可能对的总和及其相应的索引。
- 生成给定数组的所有可能对，并将所有元素对(arr[i], arr[j])及其索引(i, j)的总和存储在 HashMap M 中。
- 现在，如果值(K – sum)存在于 HashMap M 中，则再次为所有元素对(arr[i], arr[j]) 的每个总和生成给定数组的所有可能对，然后存储当前四元组在 HashMap ans 中。
- 完成上述步骤后，打印存储在 HashMap ans中的所有四元组。
下面是上述方法的实现：
Java
// Java program for the above approach
import java.io.*;
import java.util.*;
public class GFG {
// Stores the pair of indices
static class Pair {
int index1;
int index2;
// Constructor
Pair(int x, int y)
{
index1 = x;
index2 = y;
}
}
// Function to find the all the
// unique quadruplets with the
// elements at different indices
public static void
GetQuadruplets(ArrayList nums,
int target)
{
// Stores the sum mapped to
// a List Of Pair
HashMap > map
= new HashMap<>();
// Generate all possible pairs
// for the HashMap
for (int i = 0;
i < nums.size() - 1; i++) {
for (int j = i + 1;
j < nums.size(); j++) {
// Find the sum of pairs
// of elements
int sum = nums.get(i)
+ nums.get(j);
// If the sum doesn't
// exists then update
// with the new pairs
if (!map.containsKey(sum)) {
ArrayList temp
= new ArrayList<>();
Pair p = new Pair(i, j);
temp.add(p);
// Update the hashmap
map.put(sum, temp);
}
// Otherwise, push the new
// pair of indices to the
// current sum
else {
ArrayList temp
= map.get(sum);
Pair p = new Pair(i, j);
temp.add(p);
// Update the hashmap
map.put(sum, temp);
}
}
}
// Stores all the Quadruplets
HashSet > ans
= new HashSet >();
for (int i = 0;
i < nums.size() - 1; i++) {
for (int j = i + 1;
j < nums.size(); j++) {
int lookUp = target
- (nums.get(i)
+ nums.get(j));
// If the sum with value
// (K - sum) exists
if (map.containsKey(lookUp)) {
// Get the pair of
// indices of sum
ArrayList temp
= map.get(lookUp);
for (Pair pair : temp) {
// Check if i, j, k
// and l are distinct
// or not
if (pair.index1 != i
&& pair.index1 != j
&& pair.index2 != i
&& pair.index2 != j) {
ArrayList values
= new ArrayList<>();
values.add(
nums.get(pair.index1));
values.add(
nums.get(pair.index2));
values.add(nums.get(i));
values.add(nums.get(j));
// Sort the list to
// avoid duplicacy
Collections.sort(values);
// Update the hashset
ans.add(values);
}
}
}
}
}
// Print all the Quadruplets
for (ArrayList arr : ans) {
System.out.println(arr);
}
}
// Driver Code
public static void main(String[] args)
{
ArrayList arr = new ArrayList<>();
arr.add(1);
arr.add(0);
arr.add(-1);
arr.add(0);
arr.add(-2);
arr.add(2);
int K = 0;
GetQuadruplets(arr, K);
}
} 输出：
[-2, 0, 0, 2]
[-1, 0, 0, 1]
[-2, -1, 1, 2]
时间复杂度： O(N 2 * log N)
辅助空间： O(N 2 )
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。