# 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"]