计算给定 3D 数组中从源到目的地的所有可能路径

给定三个整数M 、 N和K ，任务是计算大小为(M ) 的矩阵中从单元(0, 0, 0)到单元(M-1, N-1, K-1)的所有可能路径, N, K) 。只允许在三个方向上移动，即沿三个轴的正方向，即从任何单元格(i, j, k)移动到单元格(i+1, j, k) , (i, j+1 , k)和(i, j, k+1) 。

例子：

Input: M = 1, N = 1, K = 1
Output: 1
Explanation: As the source and destination both are same, there is only one possible way to stay there.

Input: M = 2, N = 2, K = 2
Output: 6
Explanation: The possible paths are :

• (0, 0, 0) -> (0, 1, 0) -> (0, 1, 1) -> (1, 1, 1)
• (0, 0, 0) -> (0, 1, 0) -> (1, 1, 0) -> (1, 1, 1)
• (0, 0, 0) -> (1, 0, 0) -> (1, 1, 0) -> (1, 1, 1)
• (0, 0, 0) -> (1, 0, 0) -> (1, 0, 1) -> (1, 1, 1)
• (0, 0, 0) -> (0, 0, 1) -> (0, 1, 1) -> (1, 1, 1)
• (0, 0, 0) -> (0, 0, 1) -> (1, 0, 1) -> (1, 1, 1)

方法：这个问题可以通过使用动态规划来解决。请按照以下步骤解决此问题：

• 创建一个大小为M*N*K的3D数组，例如dp并将dp[0][0][0]初始化为1 。
• 使用三个嵌套循环，其中最外层从i = 0 到 i < M迭代，最内层从k = 0 到 k < K迭代，中间一个从j = 0 到 j < N迭代。
• 这里， dp[i][j][k]表示从单元格(0, 0, 0)到单元格(i, j, k)的路径数。
• 因此，任何单元格(i, j, k)只能从(i-1, j, k) 、 (i, j-1, k)和(i, j, k-1 ) 3 个其他单元格到达) .
• 因此，这里的细胞之间的关系是：

dp[i][j][k] = dp[i – 1][j][k] + dp[i][j – 1][k] + dp[i][j][k – 1]

• 使用上述关系填充整个dp矩阵，然后返回dp[M-1][N-1][K-1]作为答案。

下面是上述方法的实现：

C++

// C++ code for the above approach
 
#include 
using namespace std;
 
// Function to find to the number of ways
// from the cell(0, 0, 0)
// to cell(M-1, N-1, K-1)
int numberOfWays(int M, int N, int K)
{
    vector > > dp(
        M, vector >(
               N, vector(K)));
 
    // Initialising dp
    dp[0][0][0] = 1;
 
    for (int i = 0; i < M; ++i) {
        for (int j = 0; j < N; ++j) {
            for (int k = 0; k < K; ++k) {
                if (i == 0 and j == 0
                    and k == 0) {
                    continue;
                }
                dp[i][j][k] = 0;
                if (i - 1 >= 0) {
                    dp[i][j][k] += dp[i - 1][j][k];
                }
                if (j - 1 >= 0) {
                    dp[i][j][k] += dp[i][j - 1][k];
                }
                if (k - 1 >= 0) {
                    dp[i][j][k] += dp[i][j][k - 1];
                }
            }
        }
    }
 
    return dp[M - 1][N - 1][K - 1];
}
 
// Driver Code
int main()
{
    int M = 2, N = 2, K = 2;
    cout << numberOfWays(M, N, K);
    return 0;
}

Java

/*package whatever //do not write package name here */
import java.io.*;
 
class GFG {
 
  // Function to find to the number of ways
  // from the cell(0, 0, 0)
  // to cell(M-1, N-1, K-1)
  static int numberOfWays(int M, int N, int K)
  {
    int [][][] dp = new int[M][N][K];
 
 
    // Initialising dp
    dp[0][0][0] = 1;
 
    for (int i = 0; i < M; ++i) {
      for (int j = 0; j < N; ++j) {
        for (int k = 0; k < K; ++k) {
          if (i == 0 && j == 0
              && k == 0) {
            continue;
          }
          dp[i][j][k] = 0;
          if (i - 1 >= 0) {
            dp[i][j][k] += dp[i - 1][j][k];
          }
          if (j - 1 >= 0) {
            dp[i][j][k] += dp[i][j - 1][k];
          }
          if (k - 1 >= 0) {
            dp[i][j][k] += dp[i][j][k - 1];
          }
        }
      }
    }
 
    return dp[M - 1][N - 1][K - 1];
  }
 
  // Driver Code
  public static void main (String[] args)
  {
    int M = 2, N = 2, K = 2;
    System.out.println(numberOfWays(M, N, K));
  }
}
 
// This code is contributed by Potta Lokesh

Python3

# Python code for the above approach
 
# Function to find to the number of ways
# from the cell(0, 0, 0)
# to cell(M-1, N-1, K-1)
def numberOfWays(M, N, K):
    dp = [[[0 for i in range(K)] for j in range(N)] for k in range(M)]
     
    # Initialising dp
    dp[0][0][0] = 1;
 
    for i in range(M):
        for j in range(N):
            for k in range(K):
                if (i == 0 and j == 0 and k == 0):
                    continue;
                dp[i][j][k] = 0;
                if (i - 1 >= 0):
                    dp[i][j][k] += dp[i - 1][j][k];
                if (j - 1 >= 0):
                    dp[i][j][k] += dp[i][j - 1][k];
                if (k - 1 >= 0):
                    dp[i][j][k] += dp[i][j][k - 1];
    return dp[M - 1][N - 1][K - 1];
 
# Driver Code
 
M = 2
N = 2
K = 2;
print(numberOfWays(M, N, K));
 
# This code is contributed by gfgking

C#

/*package whatever //do not write package name here */
using System;
 
class GFG {
 
  // Function to find to the number of ways
  // from the cell(0, 0, 0)
  // to cell(M-1, N-1, K-1)
  static int numberOfWays(int M, int N, int K)
  {
    int[, , ] dp = new int[M, N, K];
 
    // Initialising dp
    dp[0, 0, 0] = 1;
 
    for (int i = 0; i < M; ++i) {
      for (int j = 0; j < N; ++j) {
        for (int k = 0; k < K; ++k) {
          if (i == 0 && j == 0 && k == 0) {
            continue;
          }
          dp[i, j, k] = 0;
          if (i - 1 >= 0) {
            dp[i, j, k] += dp[i - 1, j, k];
          }
          if (j - 1 >= 0) {
            dp[i, j, k] += dp[i, j - 1, k];
          }
          if (k - 1 >= 0) {
            dp[i, j, k] += dp[i, j, k - 1];
          }
        }
      }
    }
 
    return dp[M - 1, N - 1, K - 1];
  }
 
  // Driver Code
  public static void Main(string[] args)
  {
    int M = 2, N = 2, K = 2;
    Console.WriteLine(numberOfWays(M, N, K));
  }
}
 
// This code is contributed by ukasp.

Javascript

    // JavaScript code for the above approach
 
 
    // Function to find to the number of ways
    // from the cell(0, 0, 0)
    // to cell(M-1, N-1, K-1)
    const numberOfWays = (M, N, K) => {
        let dp = new Array(M).fill(0).map(() => new Array(N).fill(0).map(() => new Array(K).fill(0)));
        // Initialising dp
        dp[0][0][0] = 1;
 
        for (let i = 0; i < M; ++i) {
            for (let j = 0; j < N; ++j) {
                for (let k = 0; k < K; ++k) {
                    if (i == 0 && j == 0
                        && k == 0) {
                        continue;
                    }
                    dp[i][j][k] = 0;
                    if (i - 1 >= 0) {
                        dp[i][j][k] += dp[i - 1][j][k];
                    }
                    if (j - 1 >= 0) {
                        dp[i][j][k] += dp[i][j - 1][k];
                    }
                    if (k - 1 >= 0) {
                        dp[i][j][k] += dp[i][j][k - 1];
                    }
                }
            }
        }
 
        return dp[M - 1][N - 1][K - 1];
    }
 
    // Driver Code
 
    let M = 2, N = 2, K = 2;
    document.write(numberOfWays(M, N, K));
 
// This code is contributed by rakeshsahni
 

输出

6

时间复杂度： O(M*N*K)
空间复杂度： O(M*N*K)