给定三个整数N，M和K，以及由N个整数组成的数组a [] ，其中M和K表示当前元素左侧的可能移动的总数和可能移动的数量(按索引移动)。分别是一个数组，任务是通过利用所有可用的移动遍历数组来最大化可能的总和。
例子：
Input: N = 5, M = 4, K = 0, a[] = {1, 5, 4, 3, 2}
Output: 15
Explanation:
Since no moves towards left is possible, therefore, the only possible path is a[0] -> a[1] -> a[2] -> a[3] -> a[4].
Therefore, the sum calculated is 15.
Input: N = 5, M = 4, K = 1, a[]= {1, 5, 4, 3, 2}
Output: 19
Explanation:
The maximum sum can be obtained in the path a[0] -> a[1] -> a[2] -> a[1] -> a[2]
Therefore, the maximum possible sum = 19
方法：可以使用动态编程解决以上问题。请按照以下步骤解决问题：
- 初始化dp [] []矩阵，以使dp [i] [j]通过使用j个左移来存储最大和到第i个索引的最大和。
- 可以看出，只有当i≥1且k> 0时，才可以向左移动；如果i
则可以向右移动。 - 检查条件并更新上述两个步骤中可能的总和的最大值，并将其存储在dp [i] [j]中。
下面是上述方法的实现：
C++
// C++ program to implement
// the above approach
#include
using namespace std;
const int k = 1;
const int m = 4;
// Function to find the maximum sum possible
// by given moves from the array
int maxValue(int a[], int n, int pos,
int moves, int left,
int dp[][k + 1])
{
// Checking for boundary
if (moves == 0 || (pos > n - 1 || pos < 0))
return 0;
// If previously computed subproblem occurs
if (dp[pos][left] != -1)
return dp[pos][left];
int value = 0;
// If element can be moved left
if (left > 0 && pos >= 1)
// Calculate maximum possible sum
// by moving left from current index
value = max(value, a[pos] +
maxValue(a, n, pos - 1, moves - 1,
left - 1, dp));
// If element can be moved right
if (pos <= n - 1)
// Calculate maximum possible sum
// by moving right from current index
// and update the maximum sum
value = max(value, a[pos] +
maxValue(a, n, pos + 1,
moves - 1, left, dp));
// Store the maximum sum
return dp[pos][left] = value;
}
// Driver Code
int main()
{
int n = 5;
int a[] = { 1, 5, 4, 3, 2 };
int dp[n + 1][k + 1];
memset(dp, -1, sizeof(dp));
cout << (a[0] + maxValue(a, n, 1, m, k, dp))
<< endl;
}
// This code is contributed by sapnasingh4991 Java
// Java Program to implement
// the above approach
import java.io.*;
import java.util.*;
public class GFG {
// Function to find the maximum sum possible
// by given moves from the array
public static int maxValue(int a[], int n, int pos,
int moves, int left,
int dp[][])
{
// Checking for boundary
if (moves == 0 || (pos > n - 1 || pos < 0))
return 0;
// If previously computed subproblem occurs
if (dp[pos][left] != -1)
return dp[pos][left];
int value = 0;
// If element can be moved left
if (left > 0 && pos >= 1)
// Calculate maximum possible sum
// by moving left from current index
value = Math.max(
value, a[pos] + maxValue(a, n, pos - 1,
moves - 1, left - 1, dp));
// If element can be moved right
if (pos <= n - 1)
// Calculate maximum possible sum
// by moving right from current index
// and update the maximum sum
value = Math.max(
value, a[pos]
+ maxValue(a, n, pos + 1,
moves - 1, left, dp));
// Store the maximum sum
return dp[pos][left] = value;
}
// Driver Code
public static void main(String args[])
{
int n = 5;
int a[] = { 1, 5, 4, 3, 2 };
int k = 1;
int m = 4;
int dp[][] = new int[n + 1][k + 1];
for (int i[] : dp)
Arrays.fill(i, -1);
System.out.println(
(a[0] + maxValue(a, n, 1, m, k, dp)));
}
}Python3
# Python3 program to implement
# the above approach
# Function to find the maximum sum possible
# by given moves from the array
def maxValue(a, n, pos, moves, left, dp):
# Checking for boundary
if(moves == 0 or (pos > n - 1 or pos < 0)):
return 0
# If previously computed subproblem occurs
if(dp[pos][left] != -1):
return dp[pos][left]
value = 0
# If element can be moved left
if(left > 0 and pos >= 1):
# Calculate maximum possible sum
# by moving left from current index
value = max(value, a[pos] +
maxValue(a, n, pos - 1,
moves - 1,
left - 1, dp))
# If element can be moved right
if(pos <= n - 1):
# Calculate maximum possible sum
# by moving right from current index
# and update the maximum sum
value = max(value, a[pos] +
maxValue(a, n, pos + 1,
moves - 1,
left, dp))
# Store the maximum sum
dp[pos][left] = value
return dp[pos][left]
# Driver Code
n = 5
a = [ 1, 5, 4, 3, 2 ]
k = 1
m = 4
dp = [[-1 for x in range(k + 1)]
for y in range(n + 1)]
# Function call
print(a[0] + maxValue(a, n, 1, m, k, dp))
# This code is contributed by Shivam SinghC#
// C# Program to implement
// the above approach
using System;
class GFG
{
// Function to find the maximum sum possible
// by given moves from the array
public static int maxValue(int []a, int n, int pos,
int moves, int left,
int [,]dp)
{
// Checking for boundary
if (moves == 0 || (pos > n - 1 || pos < 0))
return 0;
// If previously computed subproblem occurs
if (dp[pos, left] != -1)
return dp[pos, left];
int value = 0;
// If element can be moved left
if (left > 0 && pos >= 1)
// Calculate maximum possible sum
// by moving left from current index
value = Math.Max(
value, a[pos] + maxValue(a, n, pos - 1,
moves - 1,
left - 1, dp));
// If element can be moved right
if (pos <= n - 1)
// Calculate maximum possible sum
// by moving right from current index
// and update the maximum sum
value = Math.Max(
value, a[pos] + maxValue(a, n, pos + 1,
moves - 1,
left, dp));
// Store the maximum sum
return dp[pos, left] = value;
}
// Driver Code
public static void Main(String []args)
{
int n = 5;
int []a = { 1, 5, 4, 3, 2 };
int k = 1;
int m = 4;
int [,]dp = new int[n + 1, k + 1];
for(int i = 0; i <= n; i++)
for(int j =0; j <= k; j++)
dp[i, j] = -1;
Console.WriteLine(
(a[0] + maxValue(a, n, 1, m, k, dp)));
}
}
// This code is contributed by Rajput-Ji输出：
19
时间复杂度： O(N * K)
辅助空间： O(N * K)