找到唯一的按字典序递增的四元组，总和为 B，所有元素的绝对值的 GCD 为 1

给定一个大小为N的数组 A和一个整数B，任务是找到按字典序递增的顺序排列的所有唯一四元组，使得每个四元组的元素总和为 B，并且 a 的所有元素的绝对值的 gcd四倍是 1 。

示例：

Input: A = {1, 0, -1, 0, -2, 2 }, B = 0
Output:
-2 -1 1 2
-1  0 0 1
Explanation: There are only three unique quadruplets which have sum = 0 which are {{-2, 0, 0, 2}, {-2, -1, 1, 2}, {-1, 0, 0, 1}} and out of these quadruplets only the second and the third quadrupled have gcd equal to 1.

Input: A = { 1, 5, 1, 0, 6, 0 }, B = 7
Output:
0 0 1 6
0 1 1 5

方法：想法是将每对元素的总和存储在一个hashmap中，然后遍历所有元素对，然后查找hashmap以找到对，使得quadrupled的总和等于B和绝对值的gcd的所有元素的四倍等于 1 。本文讨论了使用 hashmap 的详细方法。按照步骤解决问题。

• 将数组中每对元素的总和插入到一个哈希图mp 中。
• 初始化一个集合st，来存储所有的四元组。
• 遍历数组从 i = 0 到 N-1
  • 遍历数组从 j = i+1 到 N-1
    • 从哈希图中找出总和等于B-A[i]-A[j] 的所有对。将 v对的向量初始化为 mp[BA[i]-A[j]]。
    • 使用变量k遍历向量v
      • 如果v[k] .first 或v[k].second等于i或j，则继续下一次迭代。
      • 将四元组的元素存储在临时数组中。对临时数组进行排序。如果临时数组的所有元素的 gcd 为 1，则将临时数组插入到st 中。
• 遍历集合st并打印所有四元组。

C++

// C++ code for the above approach
#include 
using namespace std;
  
// Function to find all
// quadruplets with sum B.
void find4Sum(int A[], int N, int B)
{
    // Hashmap to store sum
    // of all pairs
    unordered_map > >
        mp;
  
    // Set to store all quadruplets
    set > st;
  
    // Traverse the array
    for (int i = 0; i < N - 1; i++) {
        // Traverse the array
        for (int j = i + 1; j < N; j++) {
            int sum = A[i] + A[j];
            // Insert sum of
            // current pair into
            // the hashmap
            mp[sum].push_back({ i, j });
        }
    }
  
    // Traverse the array
    for (int i = 0; i < N - 1; i++) {
        // Traverse the array
        for (int j = i + 1; j < N; j++) {
            int sum = A[i] + A[j];
            // Lookup the hashmap
            if (mp.find(B - sum) != mp.end()) {
                vector > v
                    = mp[B - sum];
  
                for (int k = 0; k < v.size(); k++) {
  
                    pair it = v[k];
                    if (it.first != i && it.second != i
                        && it.first != j
                        && it.second != j) {
                        vector temp;
                        temp.push_back(A[i]);
                        temp.push_back(A[j]);
                        temp.push_back(A[it.first]);
                        temp.push_back(A[it.second]);
  
                        // Stores the gcd of the
                        // quadrupled
                        int gc = abs(temp[0]);
                        gc = __gcd(abs(temp[1]), gc);
                        gc = __gcd(abs(temp[2]), gc);
                        gc = __gcd(abs(temp[3]), gc);
                        // Arrange in
                        // ascending order
                        sort(temp.begin(), temp.end());
                        // Insert into set if gcd is 1
                        if (gc == 1)
                            st.insert(temp);
                    }
                }
            }
        }
    }
    // Iterate through set
    for (auto it = st.begin(); it != st.end(); it++) {
        vector temp = *it;
        // Print the elements
        for (int i = 0; i < 4; i++) {
            cout << temp[i] << " ";
        }
        cout << endl;
    }
}
  
// Driver Code
int main()
{
    // Input
    int N = 6;
    int A[6]
        = { 1, 0, -1, 0, -2, 2 };
    int B = 0;
  
    // Function Call
    find4Sum(A, N, B);
    return 0;
}

输出

-2 -1 1 2 
-1 0 0 1 

时间复杂度：O(N^3)
辅助空间： O(N^2)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。