具有最大平均值的路径

给定大小为N * N的方阵，其中每个像元都与特定成本相关联。路径定义为特定的单元格序列，该序列从左上方的单元格开始仅向右或向下移动，并在右下方的单元格结束。我们希望找到一条在所有现有路径上具有最大平均值的路径。将平均值计算为总成本除以路径中访问的小区数。
例子：

Input : Matrix = [1, 2, 3
                  4, 5, 6
                  7, 8, 9]
Output : 5.8
Path with maximum average is, 1 -> 4 -> 7 -> 8 -> 9
Sum of the path is 29 and average is 29/5 = 5.8

一个有趣的观察是，唯一允许的移动是向右下移动，我们需要N-1个向下移动和N-1个向右移动才能到达目的地(最右边的底部)。因此，从左上角到右下角的任何路径都需要2N – 1个单元格。在平均值上，分母是固定的，我们只需要使分子最大化即可。因此，我们基本上需要找到最大求和路径。计算路径的最大和是一个经典的动态规划问题，如果dp [i] [j]代表从(0，0)到单元(i，j)的最大和，则在每个单元(i，j)，我们更新dp [ i] [j]如下

for all i, 1 <= i <= N
   dp[i][0] = dp[i-1][0] + cost[i][0];    
for all j, 1 <= j <= N
   dp[0][j] = dp[0][j-1] + cost[0][j];            
otherwise    
   dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + cost[i][j]; 

一旦我们得到所有路径的最大和，我们将这个和除以(2N – 1)，我们将得到最大平均数。

C++

//    C/C++ program to find maximum average cost path
#include 
using namespace std;
  
// Maximum number of rows and/or columns
const int M = 100;
  
// method returns maximum average of all path of
// cost matrix
double maxAverageOfPath(int cost[M][M], int N)
{
    int dp[N+1][N+1];
    dp[0][0] = cost[0][0];
  
    /* Initialize first column of total cost(dp) array */
    for (int i = 1; i < N; i++)
        dp[i][0] = dp[i-1][0] + cost[i][0];
  
    /* Initialize first row of dp array */
    for (int j = 1; j < N; j++)
        dp[0][j] = dp[0][j-1] + cost[0][j];
  
    /* Construct rest of the dp array */
    for (int i = 1; i < N; i++)
        for (int j = 1; j <= N; j++)
            dp[i][j] = max(dp[i-1][j],
                          dp[i][j-1]) + cost[i][j];
  
    // divide maximum sum by constant path
    // length : (2N - 1) for getting average
    return (double)dp[N-1][N-1] / (2*N-1);
}
  
/* Driver program to test above functions */
int main()
{
    int cost[M][M] = { {1, 2, 3},
        {6, 5, 4},
        {7, 3, 9}
    };
    printf("%f", maxAverageOfPath(cost, 3));
    return 0;
}

Java

// JAVA Code for Path with maximum average
// value
class GFG {
      
    // method returns maximum average of all
    // path of cost matrix
    public static double maxAverageOfPath(int cost[][],
                                               int N)
    {
        int dp[][] = new int[N+1][N+1];
        dp[0][0] = cost[0][0];
       
        /* Initialize first column of total cost(dp)
           array */
        for (int i = 1; i < N; i++)
            dp[i][0] = dp[i-1][0] + cost[i][0];
       
        /* Initialize first row of dp array */
        for (int j = 1; j < N; j++)
            dp[0][j] = dp[0][j-1] + cost[0][j];
       
        /* Construct rest of the dp array */
        for (int i = 1; i < N; i++)
            for (int j = 1; j < N; j++)
                dp[i][j] = Math.max(dp[i-1][j],
                           dp[i][j-1]) + cost[i][j];
       
        // divide maximum sum by constant path
        // length : (2N - 1) for getting average
        return (double)dp[N-1][N-1] / (2 * N - 1);
    }
      
    /* Driver program to test above function */
    public static void main(String[] args) 
    {
        int cost[][] = {{1, 2, 3},
                        {6, 5, 4},
                        {7, 3, 9}};
                  
        System.out.println(maxAverageOfPath(cost, 3));
    }
}
// This code is contributed by Arnav Kr. Mandal.

Python3

# Python program to find 
# maximum average cost path
  
# Maximum number of rows 
# and/or columns
M = 100
  
# method returns maximum average of 
# all path of cost matrix
def maxAverageOfPath(cost, N):
      
    dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
    dp[0][0] = cost[0][0]
  
    # Initialize first column of total cost(dp) array
    for i in range(1, N):
        dp[i][0] = dp[i - 1][0] + cost[i][0]
  
    # Initialize first row of dp array
    for j in range(1, N):
        dp[0][j] = dp[0][j - 1] + cost[0][j]
  
    # Construct rest of the dp array
    for i in range(1, N):
        for j in range(1, N):
            dp[i][j] = max(dp[i - 1][j],
                        dp[i][j - 1]) + cost[i][j]
  
    # divide maximum sum by costant path
    # length : (2N - 1) for getting average
    return dp[N - 1][N - 1] / (2 * N - 1)
  
# Driver program to test above function
cost = [[1, 2, 3],
        [6, 5, 4],
        [7, 3, 9]]
  
print(maxAverageOfPath(cost, 3))
  
# This code is contributed by Soumen Ghosh.

C#

// C# Code for Path with maximum average
// value
using System;
class GFG {
      
    // method returns maximum average of all
    // path of cost matrix
    public static double maxAverageOfPath(int [,]cost,
                                               int N)
    {
        int [,]dp = new int[N+1,N+1];
        dp[0,0] = cost[0,0];
      
        /* Initialize first column of total cost(dp)
           array */
        for (int i = 1; i < N; i++)
            dp[i, 0] = dp[i - 1,0] + cost[i, 0];
      
        /* Initialize first row of dp array */
        for (int j = 1; j < N; j++)
            dp[0, j] = dp[0,j - 1] + cost[0, j];
      
        /* Construct rest of the dp array */
        for (int i = 1; i < N; i++)
            for (int j = 1; j < N; j++)
                dp[i, j] = Math.Max(dp[i - 1, j],
                        dp[i,j - 1]) + cost[i, j];
      
        // divide maximum sum by constant path
        // length : (2N - 1) for getting average
        return (double)dp[N - 1, N - 1] / (2 * N - 1);
    }
      
    // Driver Code
    public static void Main() 
    {
        int [,]cost = {{1, 2, 3},
                       {6, 5, 4},
                       {7, 3, 9}};
                  
        Console.Write(maxAverageOfPath(cost, 3));
    }
}
  
// This code is contributed by nitin mittal.

输出：

5.2