计数唯一路径是一个矩阵，其元素乘积包含奇数个除数

给定维度为NxM的矩阵mat[][] ，任务是计算从左上角单元格(即mat[0][0] )到右下角单元格(即mat[N – 1][M – 1]的给定矩阵，使得该路径中元素的乘积包含奇数个除数。任何单元格(i, j) 的可能移动是(i, j + 1)或(i + 1, j) 。

例子：

Input: mat[][] = {{1, 1}, {3, 1}, {3, 1}}
Output: 2
Explanation: Two possible paths satisfying the condition: 

• 1->3->3->1, Product = 9, Number of Divisors of 9 are 1, 3, 9 which is odd.
• 1->1->1->1, Product = 1, Number of Divisors of 1 is 1 only which is odd.

Input: mat[][] = {{4, 1}, {4, 4}}
Output: 2
Explanation: Two possible paths satisfying the condition: 

• 4->4->4, Product = 64, Number of Divisors of 9 are 1, 2, 4, 8, 16, 32, 64 which is odd.
• 4->1->4, Product = 16, Number of Divisors of 16 are 1, 2, 4, 8, 16 which is odd.

朴素方法：最简单的方法是为给定矩阵生成从左上角单元格到右下角单元格的所有可能路径，并通过查找所有这些路径的所有元素的乘积是否具有奇数个除数使用本文中讨论的方法的除数。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
int countPaths = 0;
 
// Store the product of all paths
vector v;
 
// Function to calculate and store
// all the paths product in vector
void CountUniquePaths(int a[][105], int i,
                      int j, int m,
                      int n, int ans)
{
    // Base Case
    if (i >= m || j >= n)
        return;
 
    // If reaches the bottom right
    // corner and product is a
    // perfect square
    if (i == m - 1 && j == n - 1) {
 
        // Find square root
        long double sr = sqrt(ans * a[i][j]);
 
        // If square root is an integer
        if ((sr - floor(sr)) == 0)
            countPaths++;
    }
 
    // Move towards down in the matrix
    CountUniquePaths(a, i + 1, j, m,
                     n, ans * a[i][j]);
 
    // Move towards right in the matrix
    CountUniquePaths(a, i, j + 1, m,
                     n, ans * a[i][j]);
}
 
// Driver Code
int main()
{
    int M = 3, N = 2;
 
    // Given matrix mat[][]
    int mat[M][105] = { { 1, 1 },
                        { 3, 1 },
                        { 3, 1 } };
 
    // Function Call
    CountUniquePaths(mat, 0, 0, M, N, 1);
 
    // Print the result
    cout << countPaths;
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
import java.lang.*;
 
class GFG{
     
static int countPaths = 0;
 
// Function to calculate and store
// all the paths product in vector
static void CountUniquePaths(int[][] a, int i,
                             int j, int m,
                             int n, int ans)
{
     
    // Base Case
    if (i >= m || j >= n)
        return;
     
    // If reaches the bottom right
    // corner and product is a
    // perfect square
    if (i == m - 1 && j == n - 1)
    {
         
        // Find square root
        double sr = Math.sqrt(ans * a[i][j]);
     
        // If square root is an integer
        if ((sr - Math.floor(sr)) == 0)
            countPaths++;
    }
     
    // Move towards down in the matrix
     CountUniquePaths(a, i + 1, j, m,
                      n, ans * a[i][j]);
     
    // Move towards right in the matrix
     CountUniquePaths(a, i, j + 1, m,
                      n, ans * a[i][j]);
}
 
// Driver Code
public static void main (String[] args)
{
    int M = 3, N = 2;
     
    // Given matrix mat[][]
    int[][] mat = { { 1, 1 },
                    { 3, 1 },
                    { 3, 1 } };
     
    // Function call
    CountUniquePaths(mat, 0, 0, M, N, 1);
     
    System.out.println(countPaths); 
}
}
 
// This code is contributed by sallagondaavinashreddy7

Python3

# Python3 program for
# the above approach
import math 
countPaths = 0;
 
# Function to calculate
# and store all the paths
# product in vector
def CountUniquePaths(a, i, j,
                     m, n, ans):
 
    # Base Case
    if (i >= m or j >= n):
        return;
 
    # If reaches the bottom
    # right corner and product
    # is a perfect square
    global countPaths;
     
    if (i == m - 1 and
        j == n - 1):
 
        # Find square root
        sr = math.sqrt(ans * a[i][j]);
 
        # If square root is an integer
        if ((sr - math.floor(sr)) == 0):
            countPaths += 1;   
 
    # Move towards down
    # in the matrix
    CountUniquePaths(a, i + 1, j,
                     m, n, ans * a[i][j]);
 
    # Move towards right
    # in the matrix
    CountUniquePaths(a, i, j + 1,
                     m, n, ans * a[i][j]);
 
# Driver Code
if __name__ == '__main__':
   
    M = 3; N = 2;
 
    # Given matrix mat
    mat = [[1, 1],
           [3, 1],
           [3, 1]];
 
    # Function call
    CountUniquePaths(mat, 0,
                     0, M, N, 1);
 
    print(countPaths);
 
# This code is contributed by Princi Singh

C#

// C# program for the
// above approach
using System;
class GFG{
     
static int countPaths = 0;
 
// Function to calculate and store
// all the paths product in vector
static void CountUniquePaths(int[,] a, int i,
                             int j, int m,
                             int n, int ans)
{   
  // Base Case
  if (i >= m || j >= n)
    return;
 
  // If reaches the bottom right
  // corner and product is a
  // perfect square
  if (i == m - 1 && j == n - 1)
  {
 
    // Find square root
    double sr = Math.Sqrt(ans *
                          a[i, j]);
 
    // If square root is an integer
    if ((sr - Math.Floor(sr)) == 0)
      countPaths++;
  }
 
  // Move towards down in the matrix
  CountUniquePaths(a, i + 1, j, m,
                   n, ans * a[i, j]);
 
  // Move towards right in the matrix
  CountUniquePaths(a, i, j + 1, m,
                   n, ans * a[i, j]);
}
 
// Driver Code
public static void Main (String[] args)
{
  int M = 3, N = 2;
 
  // Given matrix mat[][]
  int[,] mat = {{1, 1},
                {3, 1},
                {3, 1}};
 
  // Function call
  CountUniquePaths(mat, 0, 0,
                   M, N, 1);
 
  Console.Write(countPaths); 
}
}
 
// This code is contributed by Chitranayal

Javascript

 
// Javascript program for the
// above approach
let countPaths = 0;
  
// Function to calculate and store
// all the paths product in vector
function CountUniquePaths(a, i, j, m, n, ans)
{
     
    // Base Case
    if (i >= m || j >= n)
        return;
      
    // If reaches the bottom right
    // corner and product is a
    // perfect square
    if (i == m - 1 && j == n - 1)
    {
          
        // Find square root
        let sr = Math.sqrt(ans * a[i][j]);
      
        // If square root is an leteger
        if ((sr - Math.floor(sr)) == 0)
            countPaths++;
    }
      
    // Move towards down in the matrix
     CountUniquePaths(a, i + 1, j, m,
                      n, ans * a[i][j]);
      
    // Move towards right in the matrix
     CountUniquePaths(a, i, j + 1, m,
                      n, ans * a[i][j]);
}
 
// Driver Code
let M = 3, N = 2;
  
// Given matrix mat[][]
let mat = [ [ 1, 1 ],
            [ 3, 1 ],
            [ 3, 1 ] ];
  
// Function call
CountUniquePaths(mat, 0, 0, M, N, 1);
  
document.write(countPaths);
 
// This code is contributed by souravghosh0416
 

输出：

2

时间复杂度： O((2 ^N )*sqrt(N))
辅助空间： O(1)

高效的方法：为了优化上述方法，思想是使用动态规划。初始化一个辅助空间dp[][][] ，该空间将存储给定矩阵的每一行从左上角到每行末尾的所有路径的乘积的数字。以下是步骤：

• 初始化一个3D辅助空间dp[][][]其中dp[i][j]将存储从单元格(0, 0)到(i, j)的所有路径的乘积。
• 要计算每个状态值，请使用dp(i – 1, j)和dp(i, j – 1) 中的所有值计算 dp[i][j] 。
• 对于给定矩阵mat[][]的第一行，将第一行的前缀积存储在dp[i][0] 处。
• 对于给定矩阵mat[][]的第一列，将第一列的前缀积存储在dp[0][i] 处。
• 现在使用两个嵌套循环i和j 将(1, 1)迭代到(N, M)并执行以下操作：
  • 将向量 top 存储在索引dp[i – 1][j] 处，并将向量 left 存储在索引dp[i][j – 1] 处。
  • 将当前元素mat[i][j]与存储在top[]和left[]中的元素的乘积存储在另一个辅助数组curr[] 中。
  • 将当前 dp 状态更新为dp[i][j] = curr 。
• 现在遍历存储在dp(N – 1, M – 1)处的数组并计算所有数字，这是一个完全平方数。
• 在上述步骤后打印最终计数。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Stores the results
vector > >
    dp(105, vector >(105));
 
// Count of unique product paths
int countPaths = 0;
 
// Function to check whether number
// is perfect square or not
bool isPerfectSquare(int n)
{
    long double sr = sqrt(n);
 
    // If square root is an integer
    return ((sr - floor(sr)) == 0);
}
 
// Function to calculate and store
// all the paths product in vector
void countUniquePaths(int a[][105],
                      int m, int n,
                      int ans)
{
    // Store the value a[0][0]
    dp[0][0].push_back(a[0][0]);
 
    // Initialize first row of dp
    for (int i = 1; i < m; i++) {
 
        // Find prefix product
        a[i][0] *= a[i - 1][0];
        dp[i][0].push_back(a[i][0]);
    }
 
    // Initialize first column of dp
    for (int i = 1; i < n; i++) {
 
        // Find the prefix product
        a[0][i] *= a[0][i - 1];
        dp[0][i].push_back(a[0][i]);
    }
 
    // Iterate over range (1, 1) to (N, M)
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
 
            // Copy  dp[i-1][j] in top[]
            vector top = dp[i - 1][j];
 
            // Copy dp[i][j-1] into left[]
            vector left = dp[i][j - 1];
 
            // Compute the values of current
            // state and store it in curr[]
            vector curr;
 
            // Find the product of a[i][j]
            // with elements at top[]
            for (int k = 0;
                 k < top.size(); k++) {
                curr.push_back(top[k] * a[i][j]);
            }
 
            // Find the product of a[i][j]
            // with elements at left[]
            for (int k = 0;
                 k < left.size(); k++) {
                curr.push_back(left[k] * a[i][j]);
            }
 
            // Update the current state
            dp[i][j] = curr;
        }
    }
 
    // Traverse dp[m - 1][n - 1]
    for (auto i : dp[m - 1][n - 1]) {
 
        // Check if perfect square
        if (isPerfectSquare(i)) {
            countPaths++;
        }
    }
}
 
// Driver Code
int main()
{
    int M = 3, N = 4;
 
    // Given matrix mat[][]
    int mat[M][105] = { { 1, 2, 3, 1 },
                        { 3, 1, 2, 4 },
                        { 2, 3, 1, 1 } };
 
    // Function Call
    countUniquePaths(mat, M, N, 1);
 
    // Print the final count
    cout << countPaths;
 
    return 0;
}

Java

// Java program to implement 
// the above approach
import java.util.*;
class GFG
{
 
  // Stores the results
  static ArrayList>> dp;
 
  // Count of unique product paths
  static int countPaths = 0;
 
  // Function to check whether number
  // is perfect square or not
  static boolean isPerfectSquare(int n)
  {
    double  sr = Math.sqrt(n);
 
    // If square root is an integer
    return ((sr - Math.floor(sr)) == 0);
  }
 
  // Function to calculate and store
  // all the paths product in vector
  static void countUniquePaths(int a[][],
                               int m, int n,
                               int ans)
  {
 
    // Store the value a[0][0]
    dp.get(0).get(0).add(a[0][0]);
 
    // Initialize first row of dp
    for (int i = 1; i < m; i++)
    {
 
      // Find prefix product
      a[i][0] *= a[i - 1][0];
      dp.get(i).get(0).add(a[i][0]);
    }
 
    // Initialize first column of dp
    for (int i = 1; i < n; i++)
    {
 
      // Find the prefix product
      a[0][i] *= a[0][i - 1];
      dp.get(0).get(i).add(a[0][i]);
    }
 
    // Iterate over range (1, 1) to (N, M)
    for (int i = 1; i < m; i++)
    {
      for (int j = 1; j < n; j++)
      {
 
        // Copy  dp[i-1][j] in top[]
        ArrayList top =
          dp.get(i - 1).get(j);
 
        // Copy dp[i][j-1] into left[]
        ArrayList left =
          dp.get(i).get(j - 1);
 
        // Compute the values of current
        // state and store it in curr[]
        ArrayList curr = new ArrayList<>();
 
        // Find the product of a[i][j]
        // with elements at top[]
        for (int k = 0;
             k < top.size(); k++)
        {
          curr.add(top.get(k) * a[i][j]);
        }
 
        // Find the product of a[i][j]
        // with elements at left[]
        for (int k = 0;
             k < left.size(); k++)
        {
          curr.add(left.get(k) * a[i][j]);
        }
 
        // Update the current state
        dp.get(i).set(j, curr);
      }
    }
 
    // Traverse dp[m - 1][n - 1]
    for (Integer i : dp.get(m - 1).get(n - 1))
    {
 
      // Check if perfect square
      if (isPerfectSquare(i))
      {
        countPaths++;
      }
    }
  }
 
  // Driver code
  public static void main (String[] args)
  {
    int M = 3, N = 4;
 
    // Given matrix mat[][]
    int mat[][] = { { 1, 2, 3, 1 },
                   { 3, 1, 2, 4 },
                   { 2, 3, 1, 1 } };
 
    dp = new ArrayList<>();
 
    for(int i = 0; i < 105; i++)
    {
      dp.add(new ArrayList<>());
      for(int j = 0; j < 105; j++)
        dp.get(i).add(new ArrayList());
    }
 
    // Function Call
    countUniquePaths(mat, M, N, 1);
 
    // Print the final count
    System.out.println(countPaths);
  }
}
 
// This code is contributed by offbeat

蟒蛇3

# Python3 program for the above approach
from math import sqrt, floor
 
# Stores the results
dp = [[[] for j in range(105)]
          for k in range(105)]
 
# Count of unique product paths
countPaths = 0
 
# Function to check whether number
# is perfect square or not
def isPerfectSquare(n):
     
    sr = sqrt(n)
 
    # If square root is an integer
    return ((sr - floor(sr)) == 0)
 
# Function to calculate and store
# all the paths product in vector
def countUniquePaths(a, m, n, ans):
     
    global dp
    global countPaths
     
    # Store the value a[0][0]
    dp[0][0].append(a[0][0])
 
    # Initialize first row of dp
    for i in range(1, m):
         
        # Find prefix product
        a[i][0] *= a[i - 1][0]
        dp[i][0].append(a[i][0])
 
    # Initialize first column of dp
    for i in range(1, n):
         
        # Find the prefix product
        a[0][i] *= a[0][i - 1]
        dp[0][i].append(a[0][i])
 
    # Iterate over range (1, 1) to (N, M)
    for i in range(1, m):
        for j in range(1, n):
             
            # Copy  dp[i-1][j] in top[]
            top = dp[i - 1][j]
 
            # Copy dp[i][j-1] into left[]
            left = dp[i][j - 1]
 
            # Compute the values of current
            # state and store it in curr[]
            curr = []
 
            # Find the product of a[i][j]
            # with elements at top[]
            for k in range(len(top)):
                curr.append(top[k] * a[i][j])
 
            # Find the product of a[i][j]
            # with elements at left[]
            for k in range(len(left)):
                curr.append(left[k] * a[i][j])
 
            # Update the current state
            dp[i][j] = curr
 
    # Traverse dp[m - 1][n - 1]
    for i in dp[m - 1][n - 1]:
         
        # Check if perfect square
        if (isPerfectSquare(i)):
            countPaths += 1
 
# Driver Code
if __name__ == '__main__':
     
    M = 3
    N = 4
 
    # Given matrix mat[][]
    mat = [ [ 1, 2, 3, 1 ],
            [ 3, 1, 2, 4 ],
            [ 2, 3, 1, 1 ] ]
 
    # Function Call
    countUniquePaths(mat, M, N, 1)
 
    # Print the final count
    print(countPaths)
 
# This code is contributed by ipg2016107

输出：

3

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live