四面体中长度为 N 的不同循环路径的数量

给定一个四面体(顶点是 A、B、C、D)，任务是从一个顶点找到长度为 n 的不同循环路径的数量。
注意：仅考虑单个顶点 B 即找到从 B 到其自身的长度为 N 的不同循环路径的数量。

例子：

Input: 2
Output: 3
The paths of length 2 which starts and ends at D are:
B-A-B
B-D-B
B-C-B

Input: 3
Output: 6

方法：动态规划可用于跟踪先前 N 值的路径数。检查剩余的移动次数以及我们在路径中移动时的位置。即 4n 个状态，每个状态有 3 个选项。观察到所有顶点 A、B、C 都是等价的。让zB初始为 1，在 0 步时，我们只能到达 B 本身。设zACD为 1，因为到达其他顶点 A、C 和 D 的路径为 0。因此形成的递推关系将是：

Paths for N steps to reach b is = zADC*3 

在每一步， zADC都乘以 2(2 个状态)并加上 zB，因为 zB 是第 n-1 步的路径数，它由剩余的 2 个状态组成。

下面是上述方法的实现：

C++

// C++ program count total number of
// paths to reach B from B
#include 
#include 
using namespace std;
 
// Function to count the number of
// steps in a tetrahedron
int countPaths(int n)
{
    // initially coming to B is B->B
    int zB = 1;
 
    // cannot reach A, D or C
    int zADC = 0;
 
    // iterate for all steps
    for (int i = 1; i <= n; i++) {
 
        // recurrence relation
        int nzB = zADC * 3;
 
        int nzADC = (zADC * 2 + zB);
 
        // memoize previous values
        zB = nzB;
        zADC = nzADC;
    }
 
    // returns steps
    return zB;
}
 
// Driver Code
int main()
{
    int n = 3;
    cout << countPaths(n);
 
    return 0;
}

Java

// Java program count total
// number of paths to reach
// B from B
import java.io.*;
 
class GFG
{
     
// Function to count the
// number of steps in a
// tetrahedron
static int countPaths(int n)
{
    // initially coming
    // to B is B->B
    int zB = 1;
 
    // cannot reach A, D or C
    int zADC = 0;
 
    // iterate for all steps
    for (int i = 1; i <= n; i++)
    {
 
        // recurrence relation
        int nzB = zADC * 3;
 
        int nzADC = (zADC * 2 + zB);
 
        // memoize previous values
        zB = nzB;
        zADC = nzADC;
    }
 
    // returns steps
    return zB;
}
 
// Driver Code
public static void main (String[] args)
{
    int n = 3;
    System.out.println(countPaths(n));
}
}
 
// This code is contributed by ajit

Python3

# Python3 program count total number of
# paths to reach B from B
 
# Function to count the number of
# steps in a tetrahedron
def countPaths(n):
     
    # initially coming to B is B->B
    zB = 1
 
    # cannot reach A, D or C
    zADC = 0
 
    # iterate for all steps
    for i in range(1, n + 1):
 
        # recurrence relation
        nzB = zADC * 3
 
        nzADC = (zADC * 2 + zB)
 
        # memoize previous values
        zB = nzB
        zADC = nzADC
     
    # returns steps
    return zB
 
# Driver code
n = 3
print(countPaths(n))
 
# This code is contributed by ashutosh450

C#

// C# program count total
// number of paths to reach
// B from B
using System;
 
class GFG{
         
// Function to count the
// number of steps in a
// tetrahedron
static int countPaths(int n)
{
     
    // initially coming
    // to B is B->B
    int zB = 1;
 
    // cannot reach A, D or C
    int zADC = 0;
 
    // iterate for all steps
    for (int i = 1; i <= n; i++)
    {
 
        // recurrence relation
        int nzB = zADC * 3;
 
        int nzADC = (zADC * 2 + zB);
 
        // memoize previous values
        zB = nzB;
        zADC = nzADC;
    }
 
    // returns steps
    return zB;
}
 
    // Driver Code
    static public void Main ()
    {
        int n = 3;
        Console.WriteLine(countPaths(n));
    }
}
 
// This code is contributed by Sach

PHP

B
    $zB = 1;
 
    // cannot reach A, D or C
    $zADC = 0;
 
    // iterate for all steps
    for ($i = 1; $i <= $n; $i++)
    {
 
        // recurrence relation
        $nzB = $zADC * 3;
 
        $nzADC = ($zADC * 2 + $zB);
 
        // memoize previous values
        $zB = $nzB;
        $zADC = $nzADC;
    }
 
    // returns steps
    return $zB;
}
 
// Driver Code
$n = 3;
echo countPaths($n);
 
 
// This code is contributed
// by Sachin
?>

Javascript

 
// Javascript program count total
// number of paths to reach
// B from B
 
// Function to count the
// number of steps in a
// tetrahedron
function countPaths(n)
{
     
    // Initially coming
    // to B is B->B
    let zB = 1;
 
    // Cannot reach A, D or C
    let zADC = 0;
 
    // Iterate for all steps
    for(let i = 1; i <= n; i++)
    {
         
        // recurrence relation
        let nzB = zADC * 3;
 
        let nzADC = (zADC * 2 + zB);
 
        // Memoize previous values
        zB = nzB;
        zADC = nzADC;
    }
 
    // Returns steps
    return zB;
}
 
// Driver code
let n = 3;
document.write(countPaths(n));
 
// This code is contributed by mukesh07      
 

输出：

6

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。