计算先减少然后增加的排列。

给定一个整数N ，计算A = [1、2，…，N]的排列数量，这些排列数量先减小然后增大。

例子：

Input: N = 5 
Output : 14
Following are the sub-sequences which are first decreasing and then increasing: 
[2, 1, 3, 4, 5], [3, 1, 2, 4, 5], [4, 1, 2, 3, 5], [5, 1, 2, 3, 4], 
[3, 2, 1, 4, 5], [4, 2, 1, 3, 5], [5, 2, 1, 3, 4], [4, 3, 1, 2, 5], 
[5, 3, 1, 2, 4], [5, 4, 1, 2, 3], [5, 4, 3, 1, 2], [5, 4, 2, 1, 3], 
[5, 3, 2, 1, 4], [4, 3, 2, 1, 5]
Input : N = 1 
Output : 0  

方法：显然，序列从减少到增加的点被排列的最小元素1占据。同样，递减序列始终跟随递增序列，这意味着最小元素的位置可以在[2，…，N-1]范围内。否则，将导致完全增加或完全减少的顺序。
例如，考虑N = 5和position = 2 ，即序列中位置2的最小元素。用Configuration = [_，1，_，_，_]计数所有可能的序列。
从其余4个元素(2、3、4、5)中选择任意1个元素以填充位置1。例如，我们选择element =3。配置看起来像[3，1，_，_，_]。只能有1个序列，即[3，1，2，4，5]。因此，对于每个要填充到位置1的选定元素，一个序列都是可能的。通过这种配置，总共可能有^4个C ₁排列。
现在，考虑配置= [_，_，1，_，_]。
通过从其余4个元素中选择任意2个元素，可以应用类似的方法，并且对于每对元素，单个有效置换都是可能的。因此，此配置的排列数量= ⁴ C ₂
N = 5的最终配置为[_，_，_，1，_]
选择其余4个元素中的任意3个，对于每个三元组，都会获得一个排列。在这种情况下，排列数= ⁴ C ₃
最终计数= ⁴ C ₁ + ⁴ C ₂ + ⁴ C ₃ (N = 5)
N的广义结果：

Count = ^N-1 C ₁ + ^N-1 C ₂ + … + ^N-1 C _N-2 ，简化为： $\sum_{i = 1}^{N-2}$ ^N-1 C _i = 2 ^N- 1-2(根据二项式定理)

C++

// C++ implementation of the above approach
#include 
 
#define ll long long
using namespace std;
 
const int mod = 1000000007;
 
// Function to compute a^n % mod
ll power(ll a, ll n)
{
 
    if (n == 0)
        return 1;
 
    ll p = power(a, n / 2) % mod;
    p = (p * p) % mod;
    if (n & 1)
        p = (p * a) % mod;
 
    return p;
}
 
// Function to count permutations that are
// first decreasing and then increasing
int countPermutations(int n)
{
 
    // For n = 1 return 0
    if (n == 1) {
        return 0;
    }
 
    // Calculate and return result
    return (power(2, n - 1) - 2) % mod;
}
 
// Driver code
int main()
{
    int n = 5;
    cout << countPermutations(n);
    return 0;
}

Java

// Java implementation of the above approach
class GFG
{
 
static final int mod = 1000000007;
 
// Function to compute a^n % mod
static long power(long a, long n)
{
 
    if (n == 0)
        return 1;
 
    long p = power(a, n / 2) % mod;
    p = (p * p) % mod;
    if ((n & 1) == 1)
        p = (p * a) % mod;
 
    return p;
}
 
// Function to count permutations that are
// first decreasing and then increasing
static int countPermutations(int n)
{
 
    // For n = 1 return 0
    if (n == 1)
    {
        return 0;
    }
 
    // Calculate and return result
    return ((int)power(2, n - 1) - 2) % mod;
}
 
// Driver code
public static void main(String args[])
{
    int n = 5;
    System.out.println(countPermutations(n));
}
}
 
// This code is contributed by Arnab Kundu

Python3

# Python3 implementation of the above approach
mod = 1000000007
 
# Function to compute a^n % mod
def power(a, n):
    if(n == 0):
        return 1
 
    p = power(a, int(n / 2)) % mod;
    p = (p * p) % mod
    if (n & 1):
        p = (p * a) % mod
 
    return p
 
# Function to count permutations that are
# first decreasing and then increasing
def countPermutations(n):
     
    # For n = 1 return 0
    if (n == 1):
        return 0
 
    # Calculate and return result
    return (power(2, n - 1) - 2) % mod
 
# Driver code
if __name__ == '__main__':
    n = 5
    print(countPermutations(n))
     
# This code is contributed by
# Surendra_Gangwar

C#

// C# implementation of the above approach
using System;
 
class GFG
{
     
static int mod = 1000000007;
 
// Function to compute a^n % mod
static long power(long a, long n)
{
 
    if (n == 0)
        return 1;
 
    long p = power(a, n / 2) % mod;
    p = (p * p) % mod;
    if ((n & 1) == 1)
        p = (p * a) % mod;
 
    return p;
}
 
// Function to count permutations that are
// first decreasing and then increasing
static int countPermutations(int n)
{
 
    // For n = 1 return 0
    if (n == 1)
    {
        return 0;
    }
 
    // Calculate and return result
    return ((int)power(2, n - 1) - 2) % mod;
}
 
// Driver code
static public void Main ()
{
    int n = 5;
    Console.WriteLine(countPermutations(n));
}
}
 
// This code is contributed by ajit..

Javascript

    // Javascript implementation of the above approach
     
    let mod = 1000000007;
   
    // Function to compute a^n % mod
    function power(a, n)
    {
 
        if (n == 0)
            return 1;
 
        let p = power(a, parseInt(n / 2, 10)) % mod;
        p = (p * p) % mod;
        if ((n & 1) == 1)
            p = (p * a) % mod;
 
        return p;
    }
 
    // Function to count permutations that are
    // first decreasing and then increasing
    function countPermutations(n)
    {
 
        // For n = 1 return 0
        if (n == 1)
        {
            return 0;
        }
 
        // Calculate and return result
        return (power(2, n - 1) - 2) % mod;
    }
     
    let n = 5;
    document.write(countPermutations(n));
         

输出：

14

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。