1. Describe a divide-and-conquer algorithm to solve this problem. Your algorithm should return such a position if it exists, or false otherwise. If A[i] = i for several different integers i, then you may return any one of them.
2. Analyze the running time of your algorithm as a function of the number of elements of A.

• How much the treasure is worth.
• How easy it would be for Yprantou (the royal thief) to acquire this treasure.

Each treasure can thus be represented by a point in the plane: the x coordinate represents how much the treasure is worth, and the ycoordinate is the difficulty of stealing that treasure (where a higher y coordinate corresponds to a treasure that is easier to steal). Given two such points, we will say that a point q = (q.x, q.y) dominates the point p = (p.x, p.y) if q.x ≥ p.x and q.y ≥ p.y. That is, q lies to the right of and above p, as illustrated in picture on the left.Clearly, a point p that is dominated by a point q is of no interest, since q is both worth more and easier to steal than p. Hence, to help you reach a decision, you only need to worry about locations that correspond to maximal points: those that no other point dominates. For instance, in the picture on the right, the points p₃, p₄ are p₆ are maximal, as you can see from the fact that their upper-right quadrants are empty.

1. Describe an algorithm that takes as input a set P of points, and a point q, and returns all points of P that q does not dominate.
2. Describe an efficient divide-and-conquer algorithm that takes as input a set P of points, and returns the list of treasures that Yprantou might be asked to steal first (that is, all maximal points of P). Hints:
   • Try to divide the problem into two subproblems so that points that are maximal in one of the subproblems are guaranteed to be maximal in P.
   • When you are combining the solutions to your subproblems, you should choose a point carefully in one subproblem, and then call your algorithm from part (a) exactly once to eliminate maximal points from the other subproblem that are not maximal in P.
3. Analyze the worst-case running time of your algorithm from (b).

Algorithm TurtleSort(A, first, last)

if (last - first ≤ 2) then
    if (last - first ≤ 1) then
        if (A[first] > A[first+1]) then
            swap (A[first], A[first+1])
        endif

        if (last - first = 2) then
            if (A[last-1] > A[last]) then
                swap (A[last-1], A[last])
            endif
            if (A[first] > A[first+1]) then
                swap (A[first], A[first+1])
            endif
        endif
    endif
    return
endif

q1 ← floor of (3*first +   last)/4
q2 ← floor of (  first +   last)/2
q3 ← floor of (  first + 3*last)/4

turtleSort(A, first, q2)
turtleSort(A, q1, q3)
turtleSort(A, q2, last)
turtleSort(A, q1, q3)
turtleSort(A, first, q2)
turtleSort(A, q1, q3)

Algorithm MCM(A, first, last)
//
// A is an array of objects, rows[X] and columns[X] are  
// properties of object X whose value is an integer.
//
if (first = last) then
	return 0
endif

min := +∞
for i := first to last - 1
	prod := rows[A[first]] * columns[A[i]] * 
                columns[A[last]];
	x := MCM(A, first, i) + MCM(A, i+1, last) + prod;

	if (x < min ) then
	    min = x
	endif
return min