Question

Let A be an array containing n numbers (positive and negative). Develop a divide and conquer algorithm that finds the two indices 1 sisjsn such that A[k] (the sum of the elements from i to j) is maximized. For example, in the array A [10,-5,-6,5, 7,-2,4, -11], the sub-array A[4:6] has the sum 5+ 7-2+4-14 and no other sub-array contains elements that sum to a value greater than 14, so for this input the algorithm should output (3, 6). Design an algorithm to solve this problem in best possible running time. (i) e down the pseudo code of your algorithm (20 marks) (ii) briefly justify what the running time of your algorithmis (10 marks).

need help in this algorithm question

Answer 1

In dirides and conquer we b«eak the same type maxumuumcan occux ii one the 5 nup Case3 없bit ltad past and.erdaự second part Cael and Ca2 can omputed, by secuswon. must andlude last elemert o ost poxt and tist unce ue t elemert Can use conbectie , ue, uan choose the longest oļ the values betwee Caae 2 and Coue 3.

Algorithm:

Function 1 (MaximumSubArraySum):

/*

This function will return a set of three values (i,j,sum)

i = starting index of maximum sum subarray

j = ending index of the maximum sum subarray

sum = sum of all elements from index i to j in the array A

*/

/*

To call the MaximumSubArraySum function we will give:

start=0 and end=A.size()-1

Therefore in the main function we will write,

MaximumSubArraySum(A,0,A.size()-1)

*/

MaximumSubArraySum(A,start,end)

/*

Base Case:

Only 1 element is present in the array

Hence we will return (start, end, sum)

and sum is A[start] as only single elements is there

*/

if (end == start)

{

return (start, end, A[start])

}

else

{

/*

Find the middle index

*/

mid = floor( (start + end)/2 )

/*

Case 1:

Recursive call on the left/first part of the array A

The left part will start from start and end at mid index

Here,

ls = starting index of max sum subarray in left part

le = ending index of max sum subarray in left part

LeftSum = sum from A[ls] to A[le]

*/

(ls,le,LeftSum) = MaximumSubArraySum(A,start,mid)

/*

Case 2:

Recursive call on the right/second part of the array A

The left part will start from mid+1 index and end at end index

Here,

rs = starting index of max sum subarray in right part

re = ending index of max sum subarray in right part

RightSum = sum from A[rs] to A[re]

*/

(rs,re,RightSum) = MaximumSubArraySum(A,mid+1,end)

/*

Case 3:

Here we calculate the sum starting in the first half of the array

and ending in the second half of the array

Here,

ms = starting index of max sum subarray in left part

me = ending index of max sum subarray in right part

MiddleSum = sum from A[ms] to A[me]

*/

(ms,me,MiddleSum) = MaxXingSubarray(A,start,mid,end)

/*

Find the maximum of the sums returned from all the three cases

*/

// If the LeftSum is greater than both MiddleSum and RightSum

if LeftSum >= MiddleSum and LeftSum >= RightSum

return (ls,le,LeftSum)

// If the RightSum is greater than both MiddleSum and LeftSum

else if RightSum >= MiddleSum and RightSum >= LeftSum

return (rs,re,RightSum)

// Else the MiddleSum is greater than both LeftSum and RightSum

else

return (ms,me,MiddleSum)

}

}

Function 2 ( Called in Function 1 ):

FindMaxSum(A,start,middle,end)

/*

Starting from the middle element we will go down to the start index

by decresing i by one everytime and going till we get a sum which is greater

than the previous sum otherwise we will stop

*/

LeftSum = -infinity;

sum = 0;

for i = middle downto start {

sum = sum + A[i]

if sum > LeftSum {

LeftSum = sum

startingIndex = i

}

}

/*

Starting from the middle element we will go up to the end index

by increasing i by one everytime and going till we get a sum which is greater

than the previous sum otherwise we will stop

*/

RightSum = -infinity;

sum = 0;

for j = middle+1 to end {

sum = sum + A[j]

if sum > RightSum

{

RightSum = sum

endingIndex = j

}

}

/*

starting index is the maximum we can go to the left

ending index is the maximum we can go to the right

*/

finalSum = LeftSum + RightSum

return (startingIndex,endingIndex,finalSum)

Time Complexity:

case cost& 1 Recunence selalion 2 2. 0
​​​​​​​

fin)-n Case 2, Tune - Olnlbqn)