计算产品等于给定数量的三胞胎的数量|套装2

给定一个由不同整数组成的数组(仅考虑正数)和数字’m’，找到乘积等于’m’的三元组数。
例子：

Input: arr[] = { 1, 4, 6, 2, 3, 8}  
            m = 24
Output: 3

Input: arr[] = { 0, 4, 6, 2, 3, 8}  
            m = 18
Output: 0

在上一篇文章中已经讨论了使用O(n)额外空间的方法。在这篇文章中，将讨论一种具有O(1)空间复杂度的方法。
方法：想法是使用三指针技术：

1. 对输入数组进行排序。
2. 将第一个元素固定为A [i]，其中i从0到数组大小– 2。
3. 固定三元组的第一个元素后，使用2指针技术查找其他两个元素。

下面是上述方法的实现：

C++

// C++ implementation of above approach
#include 
using namespace std;
  
// Function to count such triplets
int countTriplets(int arr[], int n, int m)
{
    int count = 0;
  
    // Sort the array
    sort(arr, arr + n);
    int end, start, mid;
  
    // three pointer technique
    for (end = n - 1; end >= 2; end--) {
        int start = 0, mid = end - 1;
        while (start < mid) {
  
            // Calculate the product of a triplet
            long int prod = arr[end] * arr[start] * arr[mid];
  
            // Check if that product is greater than m,
            // decrement mid
            if (prod > m)
                mid--;
  
            // Check if that product is smaller than m,
            // increment start
            else if (prod < m)
                start++;
  
            // Check if that product is equal to m,
            // decrement mid, increment start and
            // increment the count of pairs
            else if (prod == m) {
                count++;
                mid--;
                start++;
            }
        }
    }
  
    return count;
}
  
// Drivers code
int main()
{
    int arr[] = { 1, 1, 1, 1, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int m = 1;
  
    cout << countTriplets(arr, n, m);
  
    return 0;
}

Java

// Java implementation of 
// above approach
import java.io.*;
import java.util.*;
  
class GFG 
{
  
// Function to count such triplets
static int countTriplets(int arr[],
                         int n, int m)
{
    int count = 0;
  
    // Sort the array
    Arrays.sort(arr);
    int end, start, mid;
  
    // three pointer technique
    for (end = n - 1; end >= 2; end--) 
    {
        start = 0; mid = end - 1;
        while (start < mid)
        {
  
            // Calculate the product
            // of a triplet
            long prod = arr[end] * 
                        arr[start] * 
                        arr[mid];
  
            // Check if that product 
            // is greater than m,
            // decrement mid
            if (prod > m)
                mid--;
  
            // Check if that product 
            // is smaller than m,
            // increment start
            else if (prod < m)
                start++;
  
            // Check if that product is equal 
            // to m, decrement mid, increment
            // start and increment the 
            // count of pairs
            else if (prod == m) 
            {
                count++;
                mid--;
                start++;
            }
        }
    }
  
    return count;
}
  
// Driver code
public static void main (String[] args) 
{
    int []arr = { 1, 1, 1, 1, 1, 1 };
    int n = arr.length;
    int m = 1;
      
    System.out.println(countTriplets(arr, n, m));
}
}
  
// This code is contributed 
// by inder_verma.

Python3

# Python3 implementation 
# of above approach
  
# Function to count such triplets
def countTriplets(arr, n, m):
  
    count = 0
  
    # Sort the array
    arr.sort()
  
    # three pointer technique
    for end in range(n - 1, 1, -1) :
        start = 0
        mid = end - 1
        while (start < mid) :
  
            # Calculate the product 
            # of a triplet
            prod = (arr[end] * 
                    arr[start] * arr[mid])
  
            # Check if that product is 
            # greater than m, decrement mid
            if (prod > m):
                mid -= 1
  
            # Check if that product is 
            # smaller than m, increment start
            elif (prod < m):
                start += 1
  
            # Check if that product is equal 
            # to m, decrement mid, increment 
            # start and increment the count 
            # of pairs
            elif (prod == m):
                count += 1
                mid -= 1
                start += 1
  
    return count
  
# Drivers code
if __name__ == "__main__":
    arr = [ 1, 1, 1, 1, 1, 1 ]
    n = len(arr)
    m = 1
  
    print(countTriplets(arr, n, m))
  
# This code is contributed 
# by ChitraNayal

C#

// C# implementation of above approach
using System;
  
class GFG 
{
  
// Function to count such triplets
static int countTriplets(int []arr,
                         int n, int m)
{
    int count = 0;
  
    // Sort the array
    Array.Sort(arr);
    int end, start, mid;
  
    // three pointer technique
    for (end = n - 1; end >= 2; end--) 
    {
        start = 0; mid = end - 1;
        while (start < mid)
        {
  
            // Calculate the product
            // of a triplet
            long prod = arr[end] * 
                        arr[start] * 
                        arr[mid];
  
            // Check if that product 
            // is greater than m,
            // decrement mid
            if (prod > m)
                mid--;
  
            // Check if that product 
            // is smaller than m,
            // increment start
            else if (prod < m)
                start++;
  
            // Check if that product 
            // is equal to m, 
            // decrement mid, increment
            // start and increment the 
            // count of pairs
            else if (prod == m) 
            {
                count++;
                mid--;
                start++;
            }
        }
    }
  
    return count;
}
  
// Driver code
public static void Main (String []args) 
{
    int []arr = { 1, 1, 1, 1, 1, 1 };
    int n = arr.Length;
    int m = 1;
      
    Console.WriteLine(countTriplets(arr, n, m));
}
}
  
// This code is contributed
// by Arnab Kundu

PHP

= 2; $end--) { 
         $start = 0;
         $mid = $end - 1; 
        while ($start < $mid) { 
  
            // Calculate the product of a triplet 
            $prod = $arr[$end] * $arr[$start] * $arr[$mid]; 
  
            // Check if that product is greater than m, 
            // decrement mid 
            if ($prod > $m) 
                $mid--; 
  
            // Check if that product is smaller than m,
            // increment start 
            else if ($prod < $m) 
                $start++; 
  
            // Check if that product is equal to m,
            // decrement mid, increment start and 
            // increment the count of pairs 
            else if ($prod == $m) { 
                $count++; 
                $mid--; 
                $start++; 
            } 
        } 
    } 
  
    return $count; 
} 
  
// Drivers code 
   
    $arr = array( 1, 1, 1, 1, 1, 1 ); 
     $n = sizeof($arr) / sizeof($arr[0]); 
    $m = 1; 
  
    echo  countTriplets($arr, $n, $m); 
  
  
#This Code is Contributed by ajit
?>

输出：

6

时间复杂度： O(N ^ 2)
空间复杂度： O(1)