Recuento de tripletes ordenados (x, y, z) para un conjunto dado de entrada

Dados tres enteros N, M y P. La tarea es contar el número de tripletes ordenados posibles de la forma (x, y, z) donde 

1 ≤ x ≤ norte, 1 ≤ y ≤ metro y 1 ≤ z ≤ pag

Dado que este conteo puede ser muy grande, devuelva la respuesta módulo 10 ⁹ + 7 .

Ejemplos:

Entrada: N = 3, M = 3, P = 3
Salida: 6
Explicación: Los tripletes posibles son: 
(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)

Entrada: N = 1, M = 2, P = 3
Salida: 1
Explicación: Solo es posible un triplete (1, 2, 3)

Enfoque: La solución se basa en la siguiente observación.

• Di después de ordenar los tres números en orden ascendente que son A, B y C respectivamente.
• Entonces hay A opciones para elegir el primer elemento.
• Ahora esta opción no está disponible para elegir la segunda. Para el segundo hay opciones totales (B – 1).
• Ahora bien, estas dos opciones no están disponibles para la última. Entonces solo hay (C – 2) opciones para el tercero.
• Por lo tanto, el número total de posibilidades es A * (B – 1) * (C – 2).

Siga los pasos mencionados a continuación para implementar la observación anterior.

• Ordene las tres entradas en orden ascendente. Sea el orden ordenado (N1, N2, N3).
• Ahora aplica la fórmula derivada de la observación para obtener la respuesta final.
• Devuelve la respuesta final módulo 10 ⁹ + 7.

A continuación se muestra la implementación del enfoque anterior.

// C++ code to implement the above approach
#include <bits/stdc++.h>
using namespace std;
const unsigned int mod = 1000000007;
 
// Function to count the
// total number of possible triplets
long long int solve(int N, int M, int P)
{
    int nums[] = { N, M, P };
    sort(nums, nums + 3);
    long long int ans = ((nums[0] *
                         (nums[1] - 1)) % mod
                         * (nums[2] - 2) %
                         mod)% mod;
    return ans;
}
 
// Driver code
int main()
{
    int N = 3, M = 3, P = 3;
    long long int ans = solve(N, M, P);
    cout << ans << endl;
    return 0;
}

// Java code to implement the above approach
 
// Importing Arrays class from the utility class
import java.util.Arrays;
class GFG
{
 
  public static long mod = 1000000007;
 
  // Function to count the
  // total number of possible triplets
  static long solve(int N, int M, int P)
  {
    int nums[] = { N, M, P };
    Arrays.sort(nums);
    long ans = ((nums[0] * (nums[1] - 1)) % mod
                * (nums[2] - 2) % mod)
      % mod;
    return ans;
  }
 
  // Driver method
  public static void main(String[] args)
  {
    int N = 3, M = 3, P = 3;
    long ans = solve(N, M, P);
 
    System.out.println(ans);
 
  }
}
 
// This code is contributed by rakeshsahni

# Python3 program for the above approach
 
# Function to count the total number of
# possible triplets
def solve(N, M, P):
     
    mod = 1000000007
    nums = [ N, M, P ]
    nums.sort()
    ans = ((nums[0] * (nums[1] - 1)) % mod *
           (nums[2] - 2) % mod) % mod
            
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    N, M, P = 3, 3, 3
     
    ans = solve(N, M, P)
    print(ans)
 
# This code is contributed by Abhishek Thakur.

// C# code to implement the above approach
 
// Importing Arrays class from the utility class
using System;
class GFG
{
 
  static long mod = 1000000007;
 
  // Function to count the
  // total number of possible triplets
  static long solve(int N, int M, int P)
  {
    int []nums = { N, M, P };
    Array.Sort(nums);
    long ans = ((nums[0] * (nums[1] - 1)) % mod
                * (nums[2] - 2) % mod) % mod;
    return ans;
  }
 
  // Driver method
  public static void Main()
  {
    int N = 3, M = 3, P = 3;
    long ans = solve(N, M, P);
 
    Console.Write((ans));
 
  }
}
 
// This code is contributed by Samim Hossain Mondal.

  <script>
      // JavaScript code for the above approach
 
      let mod = 1000000007;
 
      // Function to count the
      // total number of possible triplets
      function solve(N, M, P) {
          let nums = [N, M, P];
          nums.sort(function (a, b) { return a - b })
          let ans = ((nums[0] *
              (nums[1] - 1)) % mod
              * (nums[2] - 2) %
              mod) % mod;
          return ans;
      }
 
      // Driver code
      let N = 3, M = 3, P = 3;
      let ans = solve(N, M, P);
      document.write(ans + '<br>')
 
// This code is contributed by Potta Lokesh
  </script>

6

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)