# Maximize sum of values in total K steps starting at position M

• Last Updated : 17 Jan, 2022

Given a sorted array arr[] containing N pairs [A, B], wherer A is the position in X axis and B is the value on that position. All the positions are distinct. The array is sorted in increasing order of position.
Given two integers M and K. The task is to maximize the sum of values that can be visited starting from the position M and taking total K steps where:

• One can move to right or left by 1 position (from x to x+1 or x-1) by taking 1 step.
• The value of any position can be added to the final sum only once.
• There is no movement along the Y axis.

Examples:

Input: arr[][] = {{2, 8}, {6, 3}, {8, 6}}, M = 5, K = 4
Output: 9
Explanation:  The optimal way is to:
Move right to position 6 and add 3. Movement 1 position.
Move right to position 8 and add 6. Movement 2 position.
Total movement 3 steps and sum = 3 + 6 = 9.

Input: arr[][] = {{1, 7}, {3, 6}, {4, 5}, {6, 5}}, M = 3, K = 4
Output: 18
Explanation: The optimal way of movement is:
Move right to position 4 and add 5.
Move left to position 1 and add 7.
Total sum = 6 + 5 + 7 = 18.
Notice that position 3 can be visited twice but value is added only once.

Input: arr[][] = {{0, 3}, {6, 4}, {8, 5}}, M = 3, K = 2
Output: 0
Explanation: Movement can be most K = 2 positions and cannot reach any position with points .

Approach: The approach is based on the concept of prefix sum. The range which can be covered standing at any position that needs to be determined at then the total points can be calculated from prefix sum array. Follow the steps below:

• Find the Prefix Sum for the maximum possible position. After that, perform two loops.
• The first loop will be when travelling to the right first and then to the left is considered.
• The second loop will occur when moving to the left first, then to the right is considered.
• The maximum number of Seeds covered in all feasible ranges is the final answer.

Below is the implementation of the above approach

## C++

 `// C++ code to implement above approach``#include ``using` `namespace` `std;` `// Function to calculate maximum points``// that can be collected``int` `maxTotalPoints(vector >& arr,``                   ``int` `M, ``int` `K)``{``    ``int` `MX = 2e5 + 2;``    ``int` `i, l, r, ans = 0;``    ` `    ``// Incremented positions by one``    ``// to make calculations easier.``    ``M++;``    ``vector<``int``> prefix_sum(MX);``    ``for` `(``auto``& it : arr)``        ``prefix_sum[it + 1] = it;``    ``for` `(i = 1; i < MX; i++)``        ``prefix_sum[i] += prefix_sum[i - 1];` `    ``for` `(r = M; r < MX && r <= M + K; r++) {``        ``l = min(M, M - (K - 2 * (r - M)));``        ``l = max(1, l);``        ``ans = max(ans, prefix_sum[r] -``                  ``prefix_sum[l - 1]);``    ``}` `    ``for` `(l = M; l > 0 && l >= M - K; l--) {``        ``r = max(M, M + (K - 2 * (M - l)));``        ``r = min(MX - 1, r);``        ``ans = max(ans, prefix_sum[r] -``                  ``prefix_sum[l - 1]);``    ``}``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``vector> arr{{2, 8}, {6, 3}, {8, 6}};``    ``int` `M = 5;``    ``int` `K = 4;``    ``cout<

## Java

 `// Java code to implement above approach``import` `java.util.*;``class` `GFG``{` `  ``// Function to calculate maximum points``  ``// that can be collected``  ``static` `int` `maxTotalPoints(``int``[][] arr,``                            ``int` `M, ``int` `K)``  ``{``    ``int` `MX = (``int``) (2e5 + ``2``);``    ``int` `i, l, r, ans = ``0``;` `    ``// Incremented positions by one``    ``// to make calculations easier.``    ``M++;``    ``int` `[]prefix_sum = ``new` `int``[MX];``    ``for` `(``int` `[]it : arr)``      ``prefix_sum[it[``0``] + ``1``] = it[``1``];``    ``for` `(i = ``1``; i < MX; i++)``      ``prefix_sum[i] += prefix_sum[i - ``1``];` `    ``for` `(r = M; r < MX && r <= M + K; r++) {``      ``l = Math.min(M, M - (K - ``2` `* (r - M)));``      ``l = Math.max(``1``, l);``      ``ans = Math.max(ans, prefix_sum[r] -``                     ``prefix_sum[l - ``1``]);``    ``}` `    ``for` `(l = M; l > ``0` `&& l >= M - K; l--) {``      ``r = Math.max(M, M + (K - ``2` `* (M - l)));``      ``r = Math.min(MX - ``1``, r);``      ``ans = Math.max(ans, prefix_sum[r] -``                     ``prefix_sum[l - ``1``]);``    ``}``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `[][]arr = {{``2``, ``8``}, {``6``, ``3``}, {``8``, ``6``}};``    ``int` `M = ``5``;``    ``int` `K = ``4``;``    ``System.out.print(maxTotalPoints(arr, M, K));``  ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python code to implement above approach` `# Function to calculate maximum points``# that can be collected``def` `maxTotalPoints(arr, M, K):``    ``MX ``=` `(``int``)(``2e5` `+` `2``);``    ``i, l, r, ans ``=` `0``, ``0``, ``0``, ``0``;` `    ``# Incremented positions by one``    ``# to make calculations easier.``    ``M ``+``=` `1``;``    ``prefix_sum ``=` `[``0` `for` `i ``in` `range``(MX)];``    ``for` `it ``in` `arr:``        ``prefix_sum[it[``0``] ``+` `1``] ``=` `it[``1``];``    ``for` `i ``in` `range``(MX):``        ``prefix_sum[i] ``+``=` `prefix_sum[i ``-` `1``];` `    ``for` `r ``in` `range``(M, (M ``+` `K ``+` `1``) ``and` `( r < MX ``and` `r <``=` `M ``+` `K)):``        ``l ``=` `min``(M, M ``-` `(K ``-` `2` `*` `(r ``-` `M)));``        ``l ``=` `max``(``1``, l);``        ``ans ``=` `max``(ans, prefix_sum[r] ``-` `prefix_sum[l ``-` `1``]);` `    ``for` `l ``in` `range``(M, (M ``-` `K ``-` `1``) ``and` `l > ``0``, ``-``1``):``        ``r ``=` `max``(M, M ``+` `(K ``-` `2` `*` `(M ``-` `l)));``        ``r ``=` `min``(MX ``-` `1``, r);``        ``ans ``=` `max``(ans, prefix_sum[r] ``-` `prefix_sum[l ``-` `1``]);` `    ``return` `ans;` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[[``2``, ``8``], [``6``, ``3``], [``8``, ``6``]];``    ``M ``=` `5``;``    ``K ``=` `4``;``    ``print``(maxTotalPoints(arr, M, K));` `    ``# This code is contributed by 29AjayKumar`

## C#

 `// C# code to implement above approach``using` `System;``class` `GFG``{` `  ``// Function to calculate maximum points``  ``// that can be collected``  ``static` `int` `maxTotalPoints(``int``[,] arr,``                            ``int` `M, ``int` `K)``  ``{``    ``int` `MX = (``int``) (2e5 + 2);``    ``int` `i, l, r, ans = 0;` `    ``// Incremented positions by one``    ``// to make calculations easier.``    ``M++;``    ``int` `[]prefix_sum = ``new` `int``[MX];``    ` `    ``for` `(``int` `it = 0; it < arr.GetLength(0); it++) {``        ``prefix_sum[arr[it, 0] + 1] = arr[it, 1];``    ``}``    ` `    ``for` `(i = 1; i < MX; i++)``      ``prefix_sum[i] += prefix_sum[i - 1];` `    ``for` `(r = M; r < MX && r <= M + K; r++) {``      ``l = Math.Min(M, M - (K - 2 * (r - M)));``      ``l = Math.Max(1, l);``      ``ans = Math.Max(ans, prefix_sum[r] -``                     ``prefix_sum[l - 1]);``    ``}` `    ``for` `(l = M; l > 0 && l >= M - K; l--) {``      ``r = Math.Max(M, M + (K - 2 * (M - l)));``      ``r = Math.Min(MX - 1, r);``      ``ans = Math.Max(ans, prefix_sum[r] -``                     ``prefix_sum[l - 1]);``    ``}``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `[,]arr = {{2, 8}, {6, 3}, {8, 6}};``    ``int` `M = 5;``    ``int` `K = 4;``    ``Console.Write(maxTotalPoints(arr, M, K));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output
`9`

Time Complexity: O(X), where X is the maximum position
Auxiliary Space: O(X)

My Personal Notes arrow_drop_up