所有合计给定值的唯一三元组

给定一个数组和一个和值，找到该数组中所有和等于给定和值的可能的唯一三元组。如果无法从阵列中形成这样的三元组，则打印“无法形成三元组”，否则打印所有唯一的三元组。例如，如果给定数组为{12，3，6，1，6，9}并且给定总和为24，则唯一三元组为(3，9，12)和(6，6，12)是24。

例子：

Input : array = {12, 3, 6, 1, 6, 9} sum = 24
Output : [[3, 9, 12], [6, 6, 12]]

Input : array = {-2, 0, 1, 1, 2} sum = 0
Output : [[-2, 0, 2], [-2, 1, 1]]

Input : array = {-2, 0, 1, 1, 2} sum = 10
Output : No triplets can be formed

方法1
在上一篇文章中，找到三元组的总和为给定值，我们已经讨论了三元组是否可以从数组中形成。
在这里，我们需要打印所有总计为给定值的三元组的唯一集合

1. 对输入数组进行排序。
2. 从数组i，j和k中找到三个索引，其中A [i] + A [j] + A [k] =给定的总和值。
3. 将第一个元素固定为A [i]，然后将i从0迭代到数组大小– 2。
4. 对于i的每次迭代，将j作为其余元素中第一个元素的索引，将k作为最后一个元素的索引。
5. 检查三元组组合A [i] + A [j] + A [k] =给定的总和值。
6. 如果获得三元组(即A [i] + A [j] + A [k] =给定的总和值)
   1. 将所有三元组添加到具有“：”分隔值的TreeSet中，以获取唯一的三元组。
   2. 增加第二个价值指数
   3. 减少第三价值指数。
   4. 重复步骤4和5，直到j
7. 否则，如果A [i] + A [j] + A [k] <给定的总和值，则增加第二个值的索引
   否则，如果A [i] + A [j] + A [k]>给定总和值，则递减第三个值索引

下面是上述想法的实现：

C++

// C++ program to find unique triplets
// that sum up to a given value.
#include 
using namespace std;
 
// Structure to define a triplet.
struct triplet
{
    int first, second, third;
};
 
// Function to find unique triplets that
// sum up to a given value.
int findTriplets(int nums[], int n, int sum)
{
    int i, j, k;
 
    // Vector to store all unique triplets.
    vector triplets;
 
    // Set to store already found triplets
    // to avoid duplication.
    unordered_set uniqTriplets;
 
    // Variable used to hold triplet
    // converted to string form.
    string temp;
 
    // Variable used to store current
    // triplet which is stored in vector
    // if it is unique.
    triplet newTriplet;
 
    // Sort the input array.
    sort(nums, nums + n);
 
    // Iterate over the array from the
    // start and consider it as the
    // first element.
    for (i = 0; i < n - 2; i++)
    {
        // index of the first element in
        // the remaining elements.
        j = i + 1;
 
        // index of the last element.
        k = n - 1;
 
        while (j < k) {
 
            // If sum of triplet is equal to
            // given value, then check if
            // this triplet is unique or not.
            // To check uniqueness, convert
            // triplet to string form and
            // then check if this string is
            // present in set or not. If
            // triplet is unique, then store
            // it in vector.
            if (nums[i] + nums[j] + nums[k] == sum)
            {
                temp = to_string(nums[i]) + " : "
                       + to_string(nums[j]) + " : "
                       + to_string(nums[k]);
                if (uniqTriplets.find(temp)
                    == uniqTriplets.end()) {
                    uniqTriplets.insert(temp);
                    newTriplet.first = nums[i];
                    newTriplet.second = nums[j];
                    newTriplet.third = nums[k];
                    triplets.push_back(newTriplet);
                }
 
                // Increment the first index
                // and decrement the last
                // index of remaining elements.
                j++;
                k--;
            }
 
            // If sum is greater than given
            // value then to reduce sum
            // decrement the last index.
            else if (nums[i] + nums[j] + nums[k] > sum)
                k--;
 
            // If sum is less than given value
            // then to increase sum increment
            // the first index of remaining
            // elements.
            else
                j++;
        }
    }
 
    // If no unique triplet is found, then
    // return 0.
    if (triplets.size() == 0)
        return 0;
 
    // Print all unique triplets stored in
    // vector.
    for (i = 0; i < triplets.size(); i++) {
        cout << "[" << triplets[i].first << ", "
             << triplets[i].second << ", "
             << triplets[i].third << "], ";
    }
}
 
// Driver Code
int main()
{
    int nums[] = { 12, 3, 6, 1, 6, 9 };
    int n = sizeof(nums) / sizeof(nums[0]);
    int sum = 24;
   
    // Function call
    if (!findTriplets(nums, n, sum))
        cout << "No triplets can be formed.";
 
    return 0;
}
 
// This code is contributed by NIKHIL JINDAL.

Java

// Java program to find all triplets with given sum
import java.util.*;
 
public class triplets {
 
    // returns all triplets whose sum is
    //  equal to sum value
    public static List >
    findTriplets(int[] nums, int sum)
    {
 
        /* Sort the elements */
        Arrays.sort(nums);
 
        List > pair
          = new ArrayList<>();
        TreeSet set
          = new TreeSet();
        List triplets
          = new ArrayList<>();
 
        /* Iterate over the array from the start
        and consider it as the first element*/
        for (int i = 0;
             i < nums.length - 2;
             i++) {
 
            // index of the first element in the
            // remaining elements
            int j = i + 1;
 
            // index of the last element
            int k = nums.length - 1;
 
            while (j < k) {
 
                if (nums[i] + nums[j]
                    + nums[k] == sum) {
 
                    String str
                      = nums[i] + ":" + nums[j]
                                 + ":" + nums[k];
 
                    if (!set.contains(str))
                    {
 
                        // To check for the unique triplet
                        triplets.add(nums[i]);
                        triplets.add(nums[j]);
                        triplets.add(nums[k]);
                        pair.add(triplets);
                        triplets = new ArrayList<>();
                        set.add(str);
                    }
 
                     // increment the second value index
                    j++;
                    
                     // decrement the third value index
                    k--;
                }
                else if (nums[i]
                         + nums[j]
                         + nums[k] < sum)
                    j++;
 
                else
                    k--;
            }
        }
        return pair;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int[] nums = { 12, 3, 6, 1, 6, 9 };
        int sum = 24;
 
        List > triplets
            = findTriplets(nums, sum);
 
        // Function call
        if (!triplets.isEmpty()) {
            System.out.println(triplets);
        }
        else {
            System.out.println("No triplets can be formed");
        }
    }
}

Python3

# Python program to find unique triplets
# that sum up to a given value.
 
# Function to find unique triplets that
# sum up to a given value.
def findTriplets(nums, n, Sum):
    i = 0
    j = 0
    k = 0
 
    # list to store all unique triplets.
    triplet = []
 
    # list to store already found triplets
    # to avoid duplication.
    uniqTriplets = []
 
    # Variable used to hold triplet
    # converted to string form.
    temp = ""
 
    # Variable used to store current
    # triplet which is stored in vector
    # if it is unique.
    newTriplet = [0, 0, 0]
 
    # Sort the input array.
    nums.sort()
 
    # Iterate over the array from the
    # start and consider it as the
    # first element.
    for i in range(n - 2):
         
        # index of the first element in
        # the remaining elements.
        j = i + 1
 
        # index of the last element.
        k = n - 1
 
        while(j < k):
           
            # If sum of triplet is equal to
            # given value, then check if
            # this triplet is unique or not.
            # To check uniqueness, convert
            # triplet to string form and
            # then check if this string is
            # present in set or not. If
            # triplet is unique, then store
            # it in list.
            if(nums[i] + nums[j] + nums[k] == Sum):
                temp = str(nums[i]) + ":" + str(nums[j]) + ":" + str(nums[k])
                if temp not in uniqTriplets:
                    uniqTriplets.append(temp)
                    newTriplet[0] = nums[i]
                    newTriplet[1] = nums[j]
                    newTriplet[2] = nums[k]
                    triplet.append(newTriplet)
                    newTriplet = [0, 0, 0]
 
                # Increment the first index
                # and decrement the last
                # index of remaining elements.
                j += 1
                k -= 1
                 
            # If sum is greater than given
            # value then to reduce sum
            # decrement the last index.
            elif(nums[i] + nums[j] + nums[k] > Sum):
                k -= 1
                 
            # If sum is less than given value
            # then to increase sum increment
            # the first index of remaining
            # elements.
            else:
                j += 1
 
    # If no unique triplet is found, then
       # return 0.
    if(len(triplet) == 0):
        return 0
     
    # Print all unique triplets stored in
    # list.
    for i in range(len(triplet)):
        print(triplet[i], end = ", ")
    return 1
 
# Driver Code
nums = [12, 3, 6, 1, 6, 9]
n = len(nums)
Sum = 24
 
# Function call
if(not findTriplets(nums, n, Sum)):
    print("No triplets can be formed.")
 
# This code is contributed by rag2127

C#

// C# program to find all triplets with given sum
using System;
using System.Collections.Generic;
 
class GFG {
 
    // returns all triplets whose sum is
    // equal to sum value
    public static List>
      findTriplets(int[] nums,int sum)
    {
 
        /* Sort the elements */
        Array.Sort(nums);
 
        List > pair
          = new List >();
        SortedSet set
          = new SortedSet();
        List triplets
          = new List();
 
        /* Iterate over the array from the start and
        consider it as the first element*/
        for (int i = 0;
             i < nums.Length - 2;
             i++) {
 
            // index of the first element in the
            // remaining elements
            int j = i + 1;
 
            // index of the last element
            int k = nums.Length - 1;
 
            while (j < k) {
                if (nums[i]
                    + nums[j]
                    + nums[k] == sum) {
                    String str
                      = nums[i] + ":" + nums[j]
                                 + ":" + nums[k];
 
                    if (!set.Contains(str))
                    {
                       
                        // To check for the unique triplet
                        triplets.Add(nums[i]);
                        triplets.Add(nums[j]);
                        triplets.Add(nums[k]);
                        pair.Add(triplets);
                        triplets = new List();
                        set.Add(str);
                    }
 
                    j++; // increment the second value index
                    k--; // decrement the third value index
                }
                else if (nums[i]
                         + nums[j]
                         + nums[k] < sum)
                    j++;
 
                else
                    k--;
            }
        }
        return pair;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[] nums = { 12, 3, 6, 1, 6, 9 };
        int sum = 24;
 
        List > triplets
          = findTriplets(nums, sum);
       
        // Function call
        if (triplets.Count != 0) {
            Console.Write("[");
            for (int i = 0; i < triplets.Count; i++)
            {
                List l = triplets[i];
                Console.Write("[");
                for (int j = 0; j < l.Count; j++)
                {
                    Console.Write(l[j]);
                    if (l.Count != j + 1)
                        Console.Write(", ");
                }
                Console.Write("]");
                if (triplets.Count != i + 1)
                    Console.Write(",");
            }
            Console.Write("]");
        }
        else
        {
            Console.WriteLine("No triplets can be formed");
        }
    }
}
 
// This code is contributed by 29AjayKumar

输出

[3, 9, 12], [6, 6, 12],

时间复杂度： O(n ² )
空间复杂度：O(n)

方法二

在这种方法中，我们将看到另一种解决此问题的方法，该方法将仅使用恒定量的空间。在此方法中，我们将检查当前元素是否与前一个元素相同，然后我们将不考虑它，而只是跳过该元素。通过使用此方法，我们将只能仅找到唯一的三元组。

算法

1. 对输入数组进行排序。
2. 对于第一个元素，将i从0迭代到n-2。
3. 对于每次迭代，我们将有两个索引start和end，其中start等于i + 1，end等于n-1。
4. 现在，我们将使用两种指针技术在从开始到结束的范围内寻找一个值为sum-a [i]的目标。
5. 在本文中，我们将查找先前的元素，如果它们相同，则我们将不帮助他们查找所有唯一的重复项。
6. 如果找到target == a [start] + a [end]，则将其打印并递增start和递减end。
7. 如果target> a [start] + a [end]，那么我们将增加start。
8. 否则我们将减少结束

下面是上述想法的实现：

C++

// C++ program to find all unique triplets
// without using any extra space.
#include 
using namespace std;
 
// Function to all find unique triplets
// without using extra space
void findTriplets(int a[], int n, int sum)
{
    int i;
 
    // Sort the input array
    sort(a, a + n);
 
    // For handling the cases when no such
    // triplets exits.
    bool flag = false;
 
    // Iterate over the array from start to n-2.
    for (i = 0; i < n - 2; i++)
    {
        if (i == 0 || a[i] > a[i - 1])
        {
            // Index of the first element in
            // remaining range.
            int start = i + 1;
 
            // Index of the last element
            int end = n - 1;
 
            // Setting our new target
            int target = sum - a[i];
 
            while (start < end)
            {
                // Checking if current element
                // is same as previous
                if (start > i + 1
                    && a[start] == a[start - 1])
                {
                    start++;
                    continue;
                }
 
                // Checking if current element is
                // same as previous
                if (end < n - 1
                    && a[end] == a[end + 1])
                {
                    end--;
                    continue;
                }
 
                // If we found the triplets then print it
                // and set the flag
                if (target == a[start] + a[end])
                {
                    cout << "[" << a[i]
                         << "," << a[start]
                         << "," << a[end] << "] ";
                    flag = true;
                    start++;
                    end--;
                }
                // If target is greater then
                //  increment the start index
                else if (target > (a[start] + a[end]))
                {
                    start++;
                }
                // If target is smaller than
                // decrement the end index
                else {
                    end--;
                }
            }
        }
    }
 
    // If no such triplets found
    if (flag == false) {
        cout << "No Such Triplets Exist"
             << "\n";
    }
}
 
// Driver code
int main()
{
    int a[] = { 12, 3, 6, 1, 6, 9 };
    int n = sizeof(a) / sizeof(a[0]);
    int sum = 24;
 
    // Function call
    findTriplets(a, n, sum);
    return 0;
}
 
// This code is contributed by Rohit

Java

// Java program to find all unique triplets
// without using any extra space.
import java.util.*;
public class Main
{
    // Function to all find unique triplets
    // without using extra space
    public static void findTriplets(int a[], int n, int sum)
    {
        int i;
       
        // Sort the input array
        Arrays.sort(a);
       
        // For handling the cases when no such
        // triplets exits.
        boolean flag = false;
       
        // Iterate over the array from start to n-2.
        for (i = 0; i < n - 2; i++)
        {
            if (i == 0 || a[i] > a[i - 1])
            {
                // Index of the first element in
                // remaining range.
                int start = i + 1;
       
                // Index of the last element
                int end = n - 1;
       
                // Setting our new target
                int target = sum - a[i];
       
                while (start < end)
                {
                    // Checking if current element
                    // is same as previous
                    if (start > i + 1
                        && a[start] == a[start - 1])
                    {
                        start++;
                        continue;
                    }
       
                    // Checking if current element is
                    // same as previous
                    if (end < n - 1
                        && a[end] == a[end + 1])
                    {
                        end--;
                        continue;
                    }
       
                    // If we found the triplets then print it
                    // and set the flag
                    if (target == a[start] + a[end])
                    {
                        System.out.print("[" + a[i]
                             + "," + a[start]
                             + "," + a[end] + "] ");
                        flag = true;
                        start++;
                        end--;
                    }
                    
                    // If target is greater then
                    //  increment the start index
                    else if (target > (a[start] + a[end]))
                    {
                        start++;
                    }
                    
                    // If target is smaller than
                    // decrement the end index
                    else {
                        end--;
                    }
                }
            }
        }
       
        // If no such triplets found
        if (flag == false) {
            System.out.print("No Such Triplets Exist");
        }
    }
     
    public static void main(String[] args) {
        int a[] = { 12, 3, 6, 1, 6, 9 };
        int n = a.length;
        int sum = 24;
       
        // Function call
        findTriplets(a, n, sum);
    }
}
 
// This code is contributed by divyeshrabadiya07

Python3

# Python3 program to find all
# unique triplets without using
# any extra space.
 
# Function to all find unique
# triplets without using extra
# space
def findTriplets(a, n, sum):
 
    # Sort the input array
    a.sort()
 
    # For handling the cases
    # when no such triplets exits.
    flag = False
 
    # Iterate over the array from
    # start to n-2.
    for i in range(n - 2):
        if (i == 0 or
            a[i] > a[i - 1]):
 
            # Index of the first
            # element in remaining
            # range.
            start = i + 1
 
            # Index of the last
            # element
            end = n - 1
 
            # Setting our new target
            target = sum - a[i]
 
            while (start < end):
 
                # Checking if current element
                # is same as previous
                if (start > i + 1 and
                    a[start] == a[start - 1]):
 
                    start += 1
                    continue
 
                # Checking if current
                # element is same as
                # previous
                if (end < n - 1 and
                    a[end] == a[end + 1]):
                    end -= 1
                    continue
 
                # If we found the triplets
                # then print it and set the
                # flag
                if (target == a[start] + a[end]):
                    print("[", a[i], ",",
                          a[start], ",",
                          a[end], "]",
                          end = " ")
                    flag = True
                    start += 1
                    end -= 1
 
                # If target is greater then
                #  increment the start index
                elif (target >
                     (a[start] + a[end])):
                    start += 1
 
                # If target is smaller than
                # decrement the end index
                else:
                    end -= 1
 
    # If no such triplets found
    if (flag == False):
        print("No Such Triplets Exist")
 
# Driver code
if __name__ == "__main__":
 
    a = [12, 3, 6, 1, 6, 9]
    n = len(a)
    sum = 24
 
    # Function call
    findTriplets(a, n, sum)
 
# This code is contributed by Chitranayal

C＃

// C# program to find all unique triplets
// without using any extra space.
using System;
using System.Collections.Generic;
class GFG {
     
    // Function to all find unique triplets
    // without using extra space
    static void findTriplets(int[] a, int n, int sum)
    {
        int i;
      
        // Sort the input array
        Array.Sort(a);
      
        // For handling the cases when no such
        // triplets exits.
        bool flag = false;
      
        // Iterate over the array from start to n-2.
        for (i = 0; i < n - 2; i++)
        {
            if (i == 0 || a[i] > a[i - 1])
            {
                // Index of the first element in
                // remaining range.
                int start = i + 1;
      
                // Index of the last element
                int end = n - 1;
      
                // Setting our new target
                int target = sum - a[i];
      
                while (start < end)
                {
                    // Checking if current element
                    // is same as previous
                    if (start > i + 1
                        && a[start] == a[start - 1])
                    {
                        start++;
                        continue;
                    }
      
                    // Checking if current element is
                    // same as previous
                    if (end < n - 1
                        && a[end] == a[end + 1])
                    {
                        end--;
                        continue;
                    }
      
                    // If we found the triplets then print it
                    // and set the flag
                    if (target == a[start] + a[end])
                    {
                        Console.Write("[" + a[i]
                             + "," + a[start]
                             + "," + a[end] + "] ");
                        flag = true;
                        start++;
                        end--;
                    }
                   
                    // If target is greater then
                    //  increment the start index
                    else if (target > (a[start] + a[end]))
                    {
                        start++;
                    }
                   
                    // If target is smaller than
                    // decrement the end index
                    else {
                        end--;
                    }
                }
            }
        }
      
        // If no such triplets found
        if (flag == false) {
            Console.WriteLine("No Such Triplets Exist");
        }
    }
 
  static void Main() {
    int[] a = { 12, 3, 6, 1, 6, 9 };
    int n = a.Length;
    int sum = 24;
  
    // Function call
    findTriplets(a, n, sum);
  }
}
 
// This code is contributed by divyesh072019

Java脚本

    // Javascript program to find all unique triplets
    // without using any extra space.
     
    // Function to all find unique triplets
    // without using extra space
    function findTriplets(a, n, sum)
    {
        let i;
 
        // Sort the input array
        a.sort(function(a, b){return a - b});
 
        // For handling the cases when no such
        // triplets exits.
        let flag = false;
 
        // Iterate over the array from start to n-2.
        for (i = 0; i < n - 2; i++)
        {
            if (i == 0 || a[i] > a[i - 1])
            {
                // Index of the first element in
                // remaining range.
                let start = i + 1;
 
                // Index of the last element
                let end = n - 1;
 
                // Setting our new target
                let target = sum - a[i];
 
                while (start < end)
                {
                    // Checking if current element
                    // is same as previous
                    if (start > i + 1
                        && a[start] == a[start - 1])
                    {
                        start++;
                        continue;
                    }
 
                    // Checking if current element is
                    // same as previous
                    if (end < n - 1
                        && a[end] == a[end + 1])
                    {
                        end--;
                        continue;
                    }
 
                    // If we found the triplets then print it
                    // and set the flag
                    if (target == a[start] + a[end])
                    {
                        document.write("[" + a[i]
                             + "," + a[start]
                             + "," + a[end] + "] ");
                        flag = true;
                        start++;
                        end--;
                    }
                    // If target is greater then
                    //  increment the start index
                    else if (target > (a[start] + a[end]))
                    {
                        start++;
                    }
                    // If target is smaller than
                    // decrement the end index
                    else {
                        end--;
                    }
                }
            }
        }
 
        // If no such triplets found
        if (flag == false) {
            document.write("No Such Triplets Exist");
        }
    }
     
    let a = [ 12, 3, 6, 1, 6, 9 ];
    let n = a.length;
    let sum = 24;
  
    // Function call
    a.sort();
    findTriplets(a, n, sum);
     
    // This code is contributed by suresh07.

输出

[3,9,12] [6,6,12]

复杂度分析：

• 时间复杂度： O(n ² )。
  由于需要两个嵌套循环，因此时间复杂度为O(n ² )。
• 辅助空间： O(1)。
  由于我们不需要额外的空间来解决此问题。