# Find Simple Closed Path for a given set of points

• Difficulty Level : Hard
• Last Updated : 13 Jul, 2022

Given a set of points, connect the dots without crossing.  Example:

```Input: points[] = {(0, 3), (1, 1), (2, 2), (4, 4),
(0, 0), (1, 2), (3, 1}, {3, 3}};

Output: Connecting points in following order would
not cause any crossing
{(0, 0), (3, 1), (1, 1), (2, 2), (3, 3),
(4, 4), (1, 2), (0, 3)}```

We strongly recommend you to minimize your browser and try this yourself first.
The idea is to use sorting.

• Find the bottom-most point by comparing y coordinate of all points. If there are two points with same y value, then the point with smaller x coordinate value is considered. Put the bottom-most point at first position. • Consider the remaining n-1 points and sort them by polor angle in counterclockwise order around points. If polor angle of two points is same, then put the nearest point first.
• Traversing the sorted array (sorted in increasing order of angle) yields simple closed path. How to compute angles?
One solution is to use trigonometric functions.
Observation: We don’t care about the actual values of the angles. We just want to sort by angle.
Idea: Use the orientation to compare angles without actually computing them!

Below is C++ implementation of above idea.

## C++

 `// A C++ program to find simple closed path for n points` `// for explanation of orientation()` `#include ` `using` `namespace` `std;`   `struct` `Point` `{` `    ``int` `x, y;` `};`   `// A global point needed for  sorting points with reference` `// to the first point. Used in compare function of qsort()` `Point p0;`   `// A utility function to swap two points` `int` `swap(Point &p1, Point &p2)` `{` `    ``Point temp = p1;` `    ``p1 = p2;` `    ``p2 = temp;` `}`   `// A utility function to return square of distance between` `// p1 and p2` `int` `dist(Point p1, Point p2)` `{` `    ``return` `(p1.x - p2.x)*(p1.x - p2.x) +` `           ``(p1.y - p2.y)*(p1.y - p2.y);` `}`   `// To find orientation of ordered triplet (p, q, r).` `// The function returns following values` `// 0 --> p, q and r are collinear` `// 1 --> Clockwise` `// 2 --> Counterclockwise` `int` `orientation(Point p, Point q, Point r)` `{` `    ``int` `val = (q.y - p.y) * (r.x - q.x) -` `              ``(q.x - p.x) * (r.y - q.y);`   `    ``if` `(val == 0) ``return` `0;  ``// collinear` `    ``return` `(val > 0)? 1: 2; ``// clockwise or counterclock wise` `}`   `// A function used by library function qsort() to sort` `//  an array of points with respect to the first point` `int` `compare(``const` `void` `*vp1, ``const` `void` `*vp2)` `{` `   ``Point *p1 = (Point *)vp1;` `   ``Point *p2 = (Point *)vp2;`   `   ``// Find orientation` `   ``int` `o = orientation(p0, *p1, *p2);` `   ``if` `(o == 0)` `     ``return` `(dist(p0, *p2) >= dist(p0, *p1))? -1 : 1;`   `   ``return` `(o == 2)? -1: 1;` `}`   `// Prints simple closed path for a set of n points.` `void` `printClosedPath(Point points[], ``int` `n)` `{` `   ``// Find the bottommost point` `   ``int` `ymin = points.y, min = 0;` `   ``for` `(``int` `i = 1; i < n; i++)` `   ``{` `     ``int` `y = points[i].y;`   `     ``// Pick the bottom-most. In case of tie, chose the` `     ``// left most point` `     ``if` `((y < ymin) || (ymin == y &&` `         ``points[i].x < points[min].x))` `        ``ymin = points[i].y, min = i;` `   ``}`   `   ``// Place the bottom-most point at first position` `   ``swap(points, points[min]);`   `   ``// Sort n-1 points with respect to the first point.` `   ``// A point p1 comes before p2 in sorted output if p2` `   ``// has larger polar angle (in counterclockwise` `   ``// direction) than p1` `   ``p0 = points;` `   ``qsort``(&points, n-1, ``sizeof``(Point), compare);`   `   ``// Now stack has the output points, print contents` `   ``// of stack` `   ``for` `(``int` `i=0; i

Output:

```(0, 0), (3, 1), (1, 1), (2, 2), (3, 3),
(4, 4), (1, 2), (0, 3), ```

Time complexity of above solution is O(n Log n) if we use a O(nLogn) sorting algorithm for sorting points.
Auxiliary Space: O(1), since no extra space has been taken.

Source:
http://www.dcs.gla.ac.uk/~pat/52233/slides/Geometry1x1.pdf