数字 1 到 N 的三元组的计数，使得中间元素始终最大

给定一个整数N ，任务是计算在[1, N]中排列三元组 ( a , b , c ) 的方式的数量，这样中间元素总是大于左右元素。

Example: 
Input: N = 4 
Output: 8 
Explaination 
For the given input N = 4 number of possible triplets are:{1, 3, 2}, {2, 3, 1}, {2, 4, 3}, {3, 4, 2}, {1, 4, 3}, {3, 4, 1}, {2, 4, 1}, {1, 4, 2}.
Input: 10 
Output: 240 
 

朴素的方法：使用三个嵌套循环检查所有三元组是否满足给定条件，并在每次三元组满足条件时不断增加它们的计数。
时间复杂度： O( N ³ )
辅助空间： O(1)
有效的方法：

1. 检查中间元素的所有可能性，并尝试找到可能的排列数量，使它们一一固定。
2. 我们可以观察到[3, N]之间的所有数字都可以占据中间位置。

Possible arrangements for every middle element: 
On placing 3 at the middle, only 2 ( = 2 * 1) possible arrangements exist {1, 3, 2} and {2, 3, 1}. 
On placing 4 at the middle, 6 ( = 3 * 2) possible arrangements exist {1, 4, 3}, {1, 4, 2}, {2, 4, 1}, {2, 4, 3}, {3, 4, 1} and {3, 4, 2}. 
On placing 5 at the middle, 12 ( = 4 * 3) possible arrangements exist. 
. 
. 
. 
On placing N – 1 at the middle, (N-2) * (N-3) possible arrangements exist. 
On placing N at the middle, (N-1) * (N-2) possible arrangements exist.
Thus, Total possible arrangements = ( N * (N-1) * (N-2)) / 3 
 

下面是上述方法的实现。

C++

// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to find Number of triplets
// for given Number N such that
// middle element is always greater
// than left and right side element.
int findArrangement(int N)
{
    // check if arrangement is
    // possible or Not
    if (N < 3)
        return 0;
 
    // else return total ways
    return ((N) * (N - 1) * (N - 2)) / 3;
}
 
// Driver code.
int main()
{
    int N = 10;
    cout << findArrangement(N);
    return 0;
}

Java

// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG{
     
// Function to find number of triplets
// for given number N such that middle
// element is always greater than left 
// and right side element.
static int findArrangement(int N)
{
     
    // Check if arrangement
    // is possible or not
    if (N < 3)
        return 0;
 
    // Else return total ways
    return ((N) * (N - 1) * (N - 2)) / 3;
}
 
// Driver code
public static void main(String[] args)
{
    int N = 10;
     
    System.out.println(findArrangement(N));
}
}
 
// This code is contributed by coder001

Python3

# Python3 program to implement
# the above approach
 
# Function to find Number of triplets
# for given Number N such that middle
# element is always greater than left 
# and right side element.
def findArrangement(N):
 
    # Check if arrangement is
    # possible or Not
    if (N < 3):
        return 0;
 
    # Else return total ways
    return ((N) * (N - 1) * (N - 2)) // 3;
 
# Driver code.
N = 10;
 
print(findArrangement(N));
 
# This code is contributed by Akanksha_Rai

C#

// C# program to implement
// the above approach
using System;
class GFG{
     
// Function to find number of triplets
// for given number N such that middle
// element is always greater than left
// and right side element.
static int findArrangement(int N)
{
     
    // Check if arrangement
    // is possible or not
    if (N < 3)
        return 0;
 
    // Else return total ways
    return ((N) * (N - 1) * (N - 2)) / 3;
}
 
// Driver code
public static void Main()
{
    int N = 10;
     
    Console.Write(findArrangement(N));
}
}
 
// This code is contributed by Code_Mech

Javascript

// Javascript program to implement
// the above approach
 
// Function to find number of triplets
// for given number N such that middle
// element is always greater than left 
// and right side element.
function findArrangement(N)
{
       
    // Check if arrangement
    // is possible or not
    if (N < 3)
        return 0;
   
    // Else return total ways
    return ((N) * (N - 1) * (N - 2)) / 3;
}
  
  // Driver Code
    let N = 10;
   document.write(findArrangement(N));
 
// This code is contributed by susmitakundugoaldanga.

输出：

240

时间复杂度： O(1)
辅助空间： O(1)