Maximize Win From Two Segments

Solution For Maximize Win From Two Segments

The Maximize Win From Two Segments problem on LeetCode requires us to find the maximum point value that can be obtained by selecting two non-overlapping segments from a given array of integers. The segments can be of any length, but their indices must not overlap.

Let’s first understand the problem statement with an example. Suppose we have an array [2, 3, 1, 6, 7] and we are allowed to select two non-overlapping segments from it. The segments can be of any length and their indices must not overlap. The possible combinations of two segments are:

  • [2, 3] and [1, 6, 7], with a total point value of 2+3+1+6+7 = 19.
  • [2, 3, 1] and [6, 7], with a total point value of 2+3+1+6+7 = 19.
  • [2, 3, 1, 6] and [7], with a total point value of 2+3+1+6+7 = 19.
  • [2] and [3, 1, 6, 7], with a total point value of 2+3+1+6+7 = 19.
  • [2, 3] and [6, 7], with a total point value of 2+3+6+7 = 18.
  • [2] and [3, 1, 6], with a total point value of 2+3+1+6 = 12.
  • [2] and [3, 1], with a total point value of 2+3+1 = 6.
  • [2] and [1, 6], with a total point value of 2+1+6 = 9.
  • [2] and [6, 7], with a total point value of 2+6+7 = 15.
  • [3, 1] and [6, 7], with a total point value of 3+1+6+7 = 17.

Therefore, the maximum point value that can be obtained by selecting two non-overlapping segments from the given array is 19.

Now, let’s see how we can solve this problem. One approach is to use dynamic programming. We can maintain two 2D tables dp1 and dp2, where dp1[i][j] represents the maximum point value that can be obtained by selecting a segment from indices 0 to i and a segment from indices i+1 to j, and dp2[i][j] represents the maximum point value that can be obtained by selecting a segment from indices i to j and a segment from indices j+1 to n-1, where n is the length of the input array.

To fill in the tables dp1 and dp2, we can use the following recurrence relations:

dp1[i][j] = max(dp1[i][j-1], dp1[i-1][j], dp2[i][j-1]) + arr[j] dp2[i][j] = max(dp2[i][j+1], dp2[i+1][j], dp1[i+1][j]) + arr[i]

The base cases for dp1 and dp2 are when the length of the segment is 1, i.e., dp1[i][i] = dp2[i][i] = arr[i].

Once we fill in the tables dp1 and dp2, we can iterate over all possible combinations of non-overlapping segments and calculate their total point value as dp1[i][j] + dp2[i][j+1], where i is the starting index of the first segment and j is the ending index of the first segment.

Finally, we return the maximum total point value obtained across all possible combinations of non-overlapping segments.

The time complexity of this approach is O(n^2), where n is the length of the input array, as we need to fill in the tables dp1 and dp2. The space complexity is also O(n^2), as we need to maintain two tables of size n x n.

Step by Step Implementation For Maximize Win From Two Segments

public int maximizeWin(int[] nums, int k) {
        // base case
        if (nums == null || nums.length == 0 || k <= 0) {
            return 0;
        }
        // dp[i][j] represents the maximum win from two segments with i and j elements
        int[][] dp = new int[k + 1][k + 1];
        // fill in the base case
        for (int i = 1; i <= k; i++) {
            dp[i][0] = dp[0][i] = 0;
        }
        // fill in the rest of the cases
        for (int i = 1; i <= k; i++) {
            for (int j = 1; j <= k; j++) {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                if (i + j - 1 < nums.length) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + nums[i + j - 1]);
                }
            }
        }
        return dp[k][k];
    }
def maximize_win_from_two_segments(arr, n, k): 
  
    # dp[i][j] stores the maximum 
    # value that can be achieved 
    # by choosing two segments 
    # arr[i..j] and arr[j+1..n-1] 
    dp = [[0 for i in range(n)] 
              for j in range(n)] 
  
    # Base cases 
    for i in range(n): 
        dp[i][i] = arr[i] 
    for i in range(n-1): 
        dp[i][i+1] = max(arr[i],  
                        arr[i+1]) 
  
    # Build the DP table in 
    # a bottom-up manner 
    for gap in range(2, n): 
        for i in range(n-gap): 
            j = gap + i 
            dp[i][j] = max(arr[i] +
                           min(dp[i+2][j],  
                               dp[i+1][j-1]), 
                           arr[j] +
                           min(dp[i][j-2],  
                               dp[i+1][j-1])) 
  
    # The value of dp[0][n-1] 
    # contains the result 
    return dp[0][n-1]
Given an array of integers A and an integer B, find the maximum value of:

(A[i] + A[j] + B) % M

where i is not equal to j, and 0 ≤ i, j < N.

Here is the code for the problem:

// We can solve this problem with two nested for loops. The outer loop // will iterate through the array from left to right, and the inner loop // will iterate through the array from right to left. For each pair of // elements, we will calculate the value of (A[i] + A[j] + B) % M and // keep track of the maximum value.

var maxValue = 0;

for (var i = 0; i < A.length; i++) {

for (var j = A.length - 1; j > i; j--) {

var value = (A[i] + A[j] + B) % M;

if (value > maxValue) {

maxValue = value;

}

}

}

return maxValue;
There are two given arrays A and B, each having n elements. You need to choose exactly one element from each array such that the sum of chosen elements is maximum and print this maximum sum.

You can choose any element only once.

Input Format

First line of input contains T - number of test cases. Its followed by 2T lines. First line of each test case contains n - size of the arrays. The next two lines contain n elements each - elements of array A and array B respectively.

Constraints

1 <= T <= 100
1 <= n <= 1000
-100 <= A[i], B[i] <= 100

Output Format

For each test case, print the maximum sum of chosen elements, separated by new line.

Sample Input 0

3
2
1 2
3 4
3
2 1 3
4 2 1
5
-10 40 -50 60
-60 -10 -40 -50

Sample Output 0

3
4
60

Explanation 0

Test Case 1

We can choose A1 = 1 and B1 = 3, which gives us a sum of 1 + 3 = 4

Test Case 2

We can choose A2 = 3 and B2 = 1, which gives us a sum of 3 + 1 = 4

Test Case 3

We can choose A3 = 60 and B3 = -60, which gives us a sum of 60 + (-60) = 0
using System; 

public class Solution {
    public int Solve(int[] nums) {
        // edge case 
        if (nums.Length == 0) return 0; 
        
        // dp[i] represents the maximum value that can be achieved by considering the first i elements 
        int[] dp = new int[nums.Length]; 
        dp[0] = nums[0]; 
        
        // we iterate through the array, considering each element as the starting element of a segment 
        for (int i = 1; i < nums.Length; i++) {
            // for each element, we iterate through all the previous elements to find the maximum value that can be achieved 
            for (int j = 0; j < i; j++) {
                // if the current element is greater than the previous element, we update the maximum value 
                if (nums[i] > nums[j]) {
                    dp[i] = Math.Max(dp[i], dp[j] + nums[i]); 
                }
            }
        }
        
        // at the end, the maximum value will be stored in the last element of the dp array 
        return dp[nums.Length - 1]; 
    }
}


Scroll to Top

Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]