Question

Let's say you are given a sequence of distinct positive numbers. We want to find a subsequence with the maximum possible sum, with the restriction that we are not allowed to take three consecutive elements from the original sequence. For example, for input 1, 6, 5, 2, 7, 9, 3, 4, the subsequence with the maximum possible sum is 6, 5, 7, 9, 4 (we have two pairs of consecutive elements 6, 5 and 7, 9 but not three consecutive elements).

Consider the following greedy strategies:

• Start with an empty subsequence. Go through the numbers in the sequence in decreasing order. For every number, if it does not cause three consecutive elements in the subsequence, include it in the subsequence (otherwise skip the number). For our example, we include 9, 7, 6, 5, 4, then we skip 3, 2, and 1.

• Go through the numbers in the sequence in increasing order, crossing them out until you get a sequence without three consecutive elements. For our example, we cross out 1, 2, and 3.

• Split the input into groups of three elements (the last group may have one or two elements). Go through the groups from left to right. For each group find the maximum element and include it in the subsequence. After that step is completed, go through the remaining elements in decreasing order, including an element if it does not cause three consecutive elements in the subsequence (otherwise skipping the element). For our example, the groups are 1, 6, 5 and 2, 7, 9 and 3, 4. We include 6, 9 and 4 in the subsequence. Then we include 7 and 5, and skip 3, 2, and 1.

None of these greedy strategies always produces the optimal answer. For each greedy strategy, provide a counterexample input, along with an optimum solution and its sum (for this input), and the solution produced by the greedy algorithm and its sum (for this input).

Give an O(n) dynamic programming solution to this problem (assume input sequence of length n).

Answer 1

Using Dynamic Programming
(1)create an auxiliary array DP[] (of same size as input array) to find the result.

DP[i] : Stores result for subarray arr[0..i], i.e.,
maximum possible sum in subarray arr[0..i]
such that no three elements are consecutive.

base case:
DP[0] = arr[0]
DP[1] = arr[0] + arr[1]
DP[2] = max(sum[1], arr[0] + arr[2], arr[1] + arr[2])

DP[i] = max(DP[i-1], DP[i-2] + arr[i],DP[i-3] + arr[i] + arr[i-1])

Algorithm:
int DP[n];
  
// Base cases (process first three elements)
if (n >= 1)
DP[0] = arr[0];
  
if (n >= 2)
DP[1] = arr[0] + arr[1];
  
if (n > 2)
DP[2] = max(DP[1], max(arr[1] + arr[2], arr[0] + arr[2]));

for (int i = 3; i < n; i++)
DP[i] = max(DP[i-1], DP[i-2] + arr[i],DP[i-3] + arr[i] + arr[i-1])

return value of DP[n-1]

Time complexity =O(n)