没有相似的相邻字符的长度为N的不同排列的计数

给定一个整数N，任务是计算长度为N的不同排列的总数，该排列仅由字母“ a”，“ b”和“ c”组成，且允许重复，因此没有两个相邻的字符相同。

Input: N = 3 
Output: 12 
Explanation: 
Possible permutations satisfying the required conditions are {aba, abc, aca, acb, bac, bab, bca, bcb, cac, cab, cba, cbc}

Input: N = 5 
Output: 48

方法：
需要进行以下观察以解决给定的问题：

1. 让我们将第一个字母固定为‘a’ 。
2. 现在，^第二个字母可以是‘b’或‘c’ ，留下了两种方式填充第二个字母。
3. 同样，第三个字母也可以用两种方式填充。如果^第二个位置的字符是“ b”，则第三个字符可以是“ a”或“ c”。如果^第二个位置的字符是“ c”，则第三个字符可以是“ a”或“ b”。
4. 同样，对于所有其余位置，根据先前位置中的字符，总是会有两个可能性。因此，如果’a’占据第一个位置，则可能的排列总数为1 * 2 * 2 * 2…* 2 = 1 * 2 ^{N – 1} 。
5. 因此，考虑到第一个字符也可以是’b’或’c’的置换总数是3 * 2 ^{N – 1} 。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
  
// Function to print the number of
// permutations possible
int countofPermutations(int N)
{
    return int(3 * pow(2, N - 1));
}
  
// Driver Code
int main()
{
    int N = 5;
    cout << countofPermutations(N);
    return 0;
}

Java

// Java program to implement
// the above approach
class GFG{
  
// Function to print the number of
// permutations possible
static int countofPermutations(int N)
{
    return (int)(3 * Math.pow(2, N - 1));
}
  
// Driver Code
public static void main(String[] args)
{
    int N = 5;
    System.out.print(countofPermutations(N));
}
}
  
// This code is contributed by 29AjayKumar

Python3

# Python3 program to implement
# the above approach
  
# Function to print the number of
# permutations possible
def countofPermutations(N):
      
    return int((3 * pow(2, N - 1)));
  
# Driver Code
if __name__ == '__main__':
      
    N = 5;
    print(countofPermutations(N));
  
# This code is contributed by amal kumar choubey

C#

// C# program to implement
// the above approach
using System;
  
class GFG{
  
// Function to print the number of
// permutations possible
static int countofPermutations(int N)
{
    return (int)(3 * Math.Pow(2, N - 1));
}
  
// Driver Code
public static void Main(String[] args)
{
    int N = 5;
      
    Console.Write(countofPermutations(N));
}
}
  
// This code is contributed by Amit Katiyar

输出：

48

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