Let x, y, and z denote the three coordinate axes in the three dimensional space R3

. A point

p ∈ R3

is specified by its coordinates along the three axes: p = (x(p), y(p), z(p)).

For p, q ∈ R3

, we say that p is dominated by q, if x(p) ≤ x(q), y(p) ≤ y(q) and z(p) ≤ z(q).

Let S = {p0, p1, . . . , pn−1} be a set of n points in R3

. pi ∈ S is called a maximal element

of S, if pi

is not dominated by any other element of S. The set of all maximal elements of S is

denoted by maxima(S). The maxima problem is: Given S, find maxima(S).

You will write an efficient program to solve this problem, using the C++ or Java Standard

Library functions.

One brute-force algorithm to solve this problem is as follows: Compare each point pi ∈ S

against all the other points in S to determine if pi

is dominated by any of those points; if pi

is not dominated by any of them, add it to the output set maxima(S). This algorithm takes

Θ(n) time for each point pi

, for a total of Θ(n

2

) time.

You will implement an efficient algorithm that is expected to run in Θ(n log n) time. The

program must be in C++ or Java only. This handout discusses the implementation in C++,

using the Standard Template Library (STL). The algorithm consists of three steps.

I. Input: The point set S is in an input file. The first line contains the value of n (the number

of points). Following that, there will be n lines, each line containing the x, y and z coordinates

of one point.

The points must be read and stored in an array P OINT S[0..(n − 1)] of POINT objects.

The P OINT S[i] object corresponds to point pi

, and has four fields: the x, y and z-coordinates

(all double); the boolean field maximal indicating whether or not the point is maximal.

II. Sorting: Sort the points (i.e., the array P OINT S) according to their z-coordinates, and

reindex them such that z(p0) ≤ z(p1) ≤ . . . ≤ z(pn−1).

The sorting must be done using the sort library function: sort(POINTS, POINTS+n); this

requires that you implement the operator<.

p < q if: z(p) < z(q), or z(p) = z(q) and y(p) < y(q),

or z(p) = z(q) and y(p) = y(q) and x(p) < x(q).

III. Finding the Maxima: Process the points, one-by-one, in decreasing order of z-coordinates.

Suppose that, at some instant, you have processed the points pn−1, pn−2, . . . , pi+1. You must

maintain the 2-dimensional maxima of these points in the (x, y)-plane; this will be called

maxima2[(i + 1)..(n − 1)]. It forms a staircase in the (x, y)-plane.

CONSIDER maintaining maxima2[(i+1)..(n−1)] in a Binary Search Tree (BST) keyed on

the y-coordinate; each node of BST corresponds to a point in maxima2[i+1..n]. As we traverse

these nodes in decreasing order of y-coordinate, their x-coordinates increase (thus forming a

staircase).

Now we want to process pi

. pi has a smaller z-coordinate than the points processed so far

(namely, pn−1, pn−2, . . . , pi+1). So, pi ∈ maxima(S) iff it is not dominated in the (x, y)-plane

by any of the points in maxima2[i + 1..n]; i.e., pi

is not under the staircase.

The test of whether pi

is dominated by any of these points (in the (x, y)-plane) is performed

as follows: Find the point q in BST such that y(q) is just above (or equal to) y(pi); then

pi ∈ maxima(S) iff x(pi) > x(q).

If x(pi) > x(q), add pi to maxima(S); also, we need to update the BST so that it represents

maxima2[i..n]. The update of the BST is done as follows: First, consider the nodes in the BST

whose y-coordinates are less than y(pi), in decreasing order of their y-coordinates; delete them

one-by-one, until you come across a point p with x(p) > x(pi). Finally, insert pi

into the BST.

Each insertion or deletion in a BST takes time Θ(height of the tree). To achieve the

Θ(n log n) runtime, the above BST must be a height-balanced binary search tree: At any

istant, the height of the tree is Θ(log of number nodes in the tree). One example of such a tree

is Red-Black Tree (see Chapter 13 in the text book). You will use the STL data structure map.

It is implemented as a Red-Black Tree. In the class, I will explain how to use map.

Variable M axNum has the number of elements in M axima(S). Print out M axNum and

M axima(S). For each point in M axima(S), also print out its array index (i.e., the index of

the point in P OINT S array).

Your program should be modular, and contain appropriate procedures/functions. No comments or other documentation is needed. Use meaningful names for all variables.

You will run your program on 10 different sets of points; your program should have a loop

for this. All the point sets are in the input file infile.txt.

The name of your program file must be maxima.[cpp or java] (corresponding to C++ or

Java programs, respectively); the name of your output file must be outfile.txt.

The price is based on these factors:

Academic level

Number of pages

Urgency

Basic features

- Free title page and bibliography
- Unlimited revisions
- Plagiarism-free guarantee
- Money-back guarantee
- 24/7 support

On-demand options

- Writer’s samples
- Part-by-part delivery
- Overnight delivery
- Copies of used sources
- Expert Proofreading

Paper format

- 275 words per page
- 12 pt Arial/Times New Roman
- Double line spacing
- Any citation style (APA, MLA, Chicago/Turabian, Harvard)

Delivering a high-quality product at a reasonable price is not enough anymore.

That’s why we have developed 5 beneficial guarantees that will make your experience with our service enjoyable, easy, and safe.

You have to be 100% sure of the quality of your product to give a money-back guarantee. This describes us perfectly. Make sure that this guarantee is totally transparent.

Read moreEach paper is composed from scratch, according to your instructions. It is then checked by our plagiarism-detection software. There is no gap where plagiarism could squeeze in.

Read moreThanks to our free revisions, there is no way for you to be unsatisfied. We will work on your paper until you are completely happy with the result.

Read moreYour email is safe, as we store it according to international data protection rules. Your bank details are secure, as we use only reliable payment systems.

Read moreBy sending us your money, you buy the service we provide. Check out our terms and conditions if you prefer business talks to be laid out in official language.

Read more
## Recent Comments