# Maximum score possible from an array with jumps of at most length K

• Difficulty Level : Basic
• Last Updated : 23 Dec, 2022

Given an array arr[] and an integer K, the 0th index, the task is to collect the maximum score possible by performing the following operations:

• Start from the 0th index of the array.
• Reach the last index of the array by jumping at most K indices in each move.
• Add the value of every index reached after each jump.
• Initialize an array dp[] to store the previously computed results.
• Now, starting from the 0th index, perform the following operations for every ith index:
• If the current index is greater than or equal to the index of the last element, return the last element of the array.
• If the value for the current index is pre-calculated, then return the pre-calculated value.
• Otherwise, calculate maximum score that can be obtained by moving to all steps in the range i + 1 to i + K and store results for respective indices in dp[] array using the following recurrence relation:

dp[i] = max(dp[i + 1], dp[i + 2], dp[i + 3], ….., dp[i + K]) + A[i].

• Now, print dp[0] as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count the maximum``// score of an index``int` `maxScore(``int` `i, ``int` `A[], ``int` `K, ``int` `N, ``int` `dp[])``{``    ``// Base Case``    ``if` `(i >= N - 1)``        ``return` `A[N - 1];` `    ``// If the value for the current``    ``// index is pre-calculated``    ``if` `(dp[i] != -1)``        ``return` `dp[i];` `    ``int` `score = INT_MIN;` `    ``// Calculate maximum score``    ``// for all the steps in the``    ``// range from i + 1 to i + k``    ``for` `(``int` `j = 1; j <= K; j++) {` `        ``// Score for index (i + j)``        ``score = max(score, maxScore(i + j, A, K, N, dp));``    ``}` `    ``// Update dp[i] and return``    ``// the maximum value``    ``return` `dp[i] = score + A[i];``}` `// Function to get maximum score``// possible from the array A[]``int` `getScore(``int` `A[], ``int` `N, ``int` `K)``{``    ``// Array to store memoization``    ``int` `dp[N];` `    ``// Initialize dp[] with -1``    ``for` `(``int` `i = 0; i < N; i++)``        ``dp[i] = -1;` `    ``cout << maxScore(0, A, K, N, dp);``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { 100, -30, -50, -15, -20, -30 };``    ``int` `K = 3;``    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``getScore(A, N, K);` `    ``return` `0;``}`

## Java

 `// JAVA program for the above approach``import` `java.io.*;``import` `java.math.*;``import` `java.util.*;``public` `class` `GFG``{` `  ``// Function to count the maximum``  ``// score of an index``  ``static` `int` `maxScore(``int` `i, ``int` `A[], ``int` `K, ``int` `N,``                      ``int` `dp[])``  ``{` `    ``// Base Case``    ``if` `(i >= N - ``1``)``      ``return` `A[N - ``1``];` `    ``// If the value for the current``    ``// index is pre-calculated``    ``if` `(dp[i] != -``1``)``      ``return` `dp[i];``    ``int` `score = Integer.MIN_VALUE;` `    ``// Calculate maximum score``    ``// for all the steps in the``    ``// range from i + 1 to i + k``    ``for` `(``int` `j = ``1``; j <= K; j++)``    ``{` `      ``// Score for index (i + j)``      ``score = Math.max(score,``                       ``maxScore(i + j, A, K, N, dp));``    ``}` `    ``// Update dp[i] and return``    ``// the maximum value``    ``return` `dp[i] = score + A[i];``  ``}` `  ``// Function to get maximum score``  ``// possible from the array A[]``  ``static` `void` `getScore(``int` `A[], ``int` `N, ``int` `K)``  ``{` `    ``// Array to store memoization``    ``int` `dp[] = ``new` `int``[N];` `    ``// Initialize dp[] with -1``    ``for` `(``int` `i = ``0``; i < N; i++)``      ``dp[i] = -``1``;``    ``System.out.println(maxScore(``0``, A, K, N, dp));``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `A[] = { ``100``, -``30``, -``50``, -``15``, -``20``, -``30` `};``    ``int` `K = ``3``;``    ``int` `N = A.length;` `    ``getScore(A, N, K);``  ``}``}` `// This code is contributed by jyoti369`

## Python3

 `# Python program for the above approach``import` `sys` `# Function to count the maximum``# score of an index``def` `maxScore(i, A, K, N, dp):``  ` `    ``# Base Case``    ``if` `(i >``=` `N ``-` `1``):``        ``return` `A[N ``-` `1``];` `    ``# If the value for the current``    ``# index is pre-calculated``    ``if` `(dp[i] !``=` `-``1``):``        ``return` `dp[i];``    ``score ``=` `1``-``sys.maxsize;` `    ``# Calculate maximum score``    ``# for all the steps in the``    ``# range from i + 1 to i + k``    ``for` `j ``in` `range``(``1``, K ``+` `1``):``      ` `        ``# Score for index (i + j)``        ``score ``=` `max``(score, maxScore(i ``+` `j, A, K, N, dp));` `    ``# Update dp[i] and return``    ``# the maximum value``    ``dp[i] ``=` `score ``+` `A[i];``    ``return` `dp[i];`  `# Function to get maximum score``# possible from the array A``def` `getScore(A, N, K):``    ``# Array to store memoization``    ``dp ``=` `[``0``]``*``N;` `    ``# Initialize dp with -1``    ``for` `i ``in` `range``(N):``        ``dp[i] ``=` `-``1``;``    ``print``(maxScore(``0``, A, K, N, dp));` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``A ``=` `[``100``, ``-``30``, ``-``50``, ``-``15``, ``-``20``, ``-``30``];``    ``K ``=` `3``;``    ``N ``=` `len``(A);` `    ``getScore(A, N, K);``    ` `# This code contributed by shikhasingrajput`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{` `  ``// Function to count the maximum``  ``// score of an index``  ``static` `int` `maxScore(``int` `i, ``int` `[]A, ``int` `K, ``int` `N,``                      ``int` `[]dp)``  ``{` `    ``// Base Case``    ``if` `(i >= N - 1)``      ``return` `A[N - 1];` `    ``// If the value for the current``    ``// index is pre-calculated``    ``if` `(dp[i] != -1)``      ``return` `dp[i];``    ``int` `score = ``int``.MinValue;` `    ``// Calculate maximum score``    ``// for all the steps in the``    ``// range from i + 1 to i + k``    ``for` `(``int` `j = 1; j <= K; j++)``    ``{` `      ``// Score for index (i + j)``      ``score = Math.Max(score,``                       ``maxScore(i + j, A, K, N, dp));``    ``}` `    ``// Update dp[i] and return``    ``// the maximum value``    ``return` `dp[i] = score + A[i];``  ``}` `  ``// Function to get maximum score``  ``// possible from the array A[]``  ``static` `void` `getScore(``int` `[]A, ``int` `N, ``int` `K)``  ``{` `    ``// Array to store memoization``    ``int` `[]dp = ``new` `int``[N];` `    ``// Initialize dp[] with -1``    ``for` `(``int` `i = 0; i < N; i++)``      ``dp[i] = -1;``    ``Console.WriteLine(maxScore(0, A, K, N, dp));``  ``}` `// Driver Code``static` `public` `void` `Main()``{``    ``int` `[]A = { 100, -30, -50, -15, -20, -30 };``    ``int` `K = 3;``    ``int` `N = A.Length;` `    ``getScore(A, N, K);``}``}` `// This code is contributed by jana_sayantan.`

## Javascript

 ``

Output

`55`

Time Complexity: O(N * K)

Auxiliary Space: O(N * K)

Efficient Approach: Follow the steps below to solve the problem

• Initialize a Max Heap to store the result of previous K indices.
• Now, traverse the array A[] to calculate the maximum score for all indices.
• For 0th index, the score will be the value at the 0th index.
• Now, for every ith index in the range [1, N – 1].
• Firstly, remove maximum scores from the Max Heap for indices less than i – K.
• Now calculate the maximum score for ith index.
Maximum score = A[i] + score at the top of the Max Heap.
• Now insert the maximum score into the max heap with its index.
• Return the maximum score obtained.

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Structure to sort a priority queue on``// the basis of first element of the pair``struct` `mycomp {``    ``bool` `operator()(pair<``int``, ``int``> p1,``                    ``pair<``int``, ``int``> p2)``    ``{``        ``return` `p1.first < p2.first;``    ``}``};` `// Function to calculate maximum``// score possible from the array A[]``int` `maxScore(``int` `A[], ``int` `K, ``int` `N)``{``    ``// Stores the score of previous k indices``    ``priority_queue,``                ``vector >, mycomp>``        ``maxheap;` `    ``// Stores the maximum``    ``// score for current index``    ``int` `maxScore = 0;` `    ``// Maximum score at first index``    ``maxheap.push({ A[0], 0 });` `    ``// Traverse the array to calculate``    ``// maximum score for all indices``    ``for` `(``int` `i = 1; i < N; i++) {` `        ``// Remove maximum scores for``        ``// indices less than i - K``        ``while` `(maxheap.top().second < (i - K)) {``            ``maxheap.pop();``        ``}` `        ``// Calculate maximum score for current index``        ``maxScore = A[i] + maxheap.top().first;` `        ``// Push maximum score of``        ``// current index along``        ``// with index in maxheap``        ``maxheap.push({ maxScore, i });``    ``}` `    ``// Return the maximum score``    ``return` `maxScore;``}` `// Driver Code``int` `main()``{``    ``int` `A[] = { -44, -17, -54, 79 };``    ``int` `K = 2;``    ``int` `N = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``// Function call to calculate``    ``// maximum score from the array A[]``    ``cout << maxScore(A, K, N);` `    ``return` `0;``}`

## Java

 `// Java code for the above approach:` `import` `java.util.*;` `public` `class` `Main {``    ``static` `class` `IntPair {``        ``int` `first;``        ``int` `second;``        ``IntPair(``int` `x, ``int` `y)``        ``{``            ``this``.first = x;``            ``this``.second = y;``        ``}``    ``}``    ``static` `class` `HeapComparator``        ``implements` `Comparator {``        ``public` `int` `compare(IntPair p1, IntPair p2)``        ``{``            ``if` `(p1.first < p2.first)``                ``return` `1``;``            ``else` `if` `(p1.first > p2.first)``                ``return` `-``1``;``            ``return` `0``;``        ``}``    ``}``    ``// Function to calculate maximum``    ``// score possible from the array A[]``    ``static` `int` `maxScore(``int` `A[], ``int` `K, ``int` `N)``    ``{``        ``// Stores the score of previous k indices``        ``PriorityQueue maxheap``            ``= ``new` `PriorityQueue(``                ``new` `HeapComparator());` `        ``// Stores the maximum``        ``// score for current index``        ``int` `maxScore = ``0``;` `        ``// Maximum score at first index``        ``maxheap.add(``new` `IntPair(A[``0``], ``0``));` `        ``// Traverse the array to calculate``        ``// maximum score for all indices``        ``for` `(``int` `i = ``1``; i < N; i++) {` `            ``// Remove maximum scores for``            ``// indices less than i - K``            ``while` `(maxheap.peek().second < (i - K)) {``                ``maxheap.remove();``            ``}` `            ``// Calculate maximum score for current index``            ``maxScore = A[i] + maxheap.peek().first;` `            ``// Push maximum score of``            ``// current index along``            ``// with index in maxheap``            ``maxheap.add(``new` `IntPair(maxScore, i));``        ``}` `        ``// Return the maximum score``        ``return` `maxScore;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `A[] = { -``44``, -``17``, -``54``, ``79` `};``        ``int` `K = ``2``;``        ``int` `N = A.length;` `        ``// Function call to calculate``        ``// maximum score from the array A[]``        ``System.out.println(maxScore(A, K, N));``    ``}``}` `// This code has been contributed by Sachin Sahara``// (sachin801)`

## Python3

 `# Python program for the above approach` `# Function to calculate maximum``# score possible from the array A[]``def` `maxScore(A, K, N):``  ` `    ``# Stores the score of previous k indices``    ``maxheap ``=` `[]``    ` `    ``# Stores the maximum``    ``# score for current index``    ``maxScore ``=` `0``    ` `    ``# Maximum score at first index``    ``maxheap.append([A[``0``], ``0``])``    ` `    ``# Traverse the array to calculate``    ``# maximum score for all indices``    ``for` `i ``in` `range``(``1``, N):``      ` `        ``# Remove maximum scores for``        ``# indices less than i - K``        ``while``(maxheap[``len``(maxheap) ``-` `1``][``1``] < (i ``-` `K)):``            ``maxheap.pop()``            ` `        ``# Calculate maximum score for current index``        ``maxScore ``=` `A[i] ``+` `maxheap[``len``(maxheap) ``-` `1``][``0``]``        ` `        ``# Push maximum score of``        ``# current index along``        ``# with index in maxheap``        ``maxheap.append([maxScore, i])``        ``maxheap.sort()``        ` `    ``# Return the maximum score``    ``return` `maxScore` `# Driver Code``A ``=` `[``-``44``, ``-``17``, ``-``54``, ``79``]``K ``=` `2``N ``=` `len``(A)` `# Function call to calculate``# maximum score from the array A[]``print``(maxScore(A, K, N))` `# This code is contributed by Pushpesh Raj.`

## C#

 `// C# program for the above approach` `using` `System;``using` `System.Collections.Generic;` `class` `GFG` `{``  ``// Function to calculate maximum``  ``// score possible from the array A[]``  ``static` `int` `maxScore(``int``[] A, ``int` `K, ``int` `N)``  ``{``    ``// Stores the score of previous k indices``    ``List> maxheap = ``new` `List> ();` `    ``// Stores the maximum``    ``// score for current index``    ``int` `maxScore = 0;` `    ``// Maximum score at first index``    ``maxheap.Add(Tuple.Create(A[0], 0));` `    ``// Traverse the array to calculate``    ``// maximum score for all indices``    ``for` `(``int` `i = 1; i < N; i++) {` `      ``// Remove maximum scores for``      ``// indices less than i - K``      ``while` `(maxheap[0].Item2 < (i - K)) {``        ``maxheap.RemoveAt(0);``      ``}` `      ``// Calculate maximum score for current index``      ``maxScore = A[i] + maxheap[0].Item1;` `      ``// Add maximum score of``      ``// current index along``      ``// with index in maxheap``      ``maxheap.Add(Tuple.Create(maxScore, i ));``      ``maxheap.Sort();``      ``maxheap.Reverse();``    ``}` `    ``// Return the maximum score``    ``return` `maxScore;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] A = { -44, -17, -54, 79 };``    ``int` `K = 2;``    ``int` `N = A.Length;` `    ``// Function call to calculate``    ``// maximum score from the array A[]``    ``Console.WriteLine(maxScore(A, K, N));` `  ``}``}` `// This code is contributed by phasing17.`

## Javascript

 ``

Output

`18`

Time Complexity: O(N * log K)

Auxiliary Space: O(N)

My Personal Notes arrow_drop_up