squarepie solution - algorithm

Question

The following problem was asked in the programming contest, which is over now.
Squarepie program
I tried the best solution I could, but always got time limit exceeded error. My solution was as follows.
First add all the edges in a structure which is first sorted by length and then by their position. I was having two different structures for x and y edges. Find the outside rectangle, and add it to the stack. Now for each rectangle in the stack find if there is any intersecting edge. If yes divide this rectangle in two by this edge and add both to the stack. If failed to find any bisecting edge, add the area of the rectangle in priority queue. At the end print elements from priority queue.
I now wonder is there any faster solution.
Edit :-
Attaching my solution.
My Final solution

Answer 1

Everything looks good except for getLargestRect(), which you really overcomplicate. Just return rectangle(minX, minY, maxX, maxY). You can find the mins and maxs in linear time. The current implementation is O(n2) when all the lines have the same length.
I also coded up my own algorithm, if you want to have a look at a different approach. My idea was to store all the vertical lines in a fancy data structure, then scan through the horizontal lines and find the rectangles they close off.
When looking at the horizontal line h, all the vertical lines with y1 < h.y && y2 >= h.y are stored in a map by their x value. The current horizontal line forms rectangles with all the vertical lines from map[h.x1] to map[h.x2]. The outer two lines extend past h.y, but all the middle ones must end at h.y and are therefore removed from the map after the area of their rectangles has been calculated. The vertical lines that need to be added to the map for each horizontal line are found efficiently by sorting the verticals according to their y1 value.
Here is the code:
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#define min(a, b) ((a) < (b) ? (a) : (b))
#define max(a, b) ((a) < (b) ? (b) : (a))
using namespace std;
class Horizontal
{
public:
int x1, x2, y;
Horizontal(int x1, int x2, int y) : x1(x1), x2(x2), y(y) {}
static bool comp(const Horizontal & a, const Horizontal & b)
{
return a.y < b.y;
}
};
class Vertical
{
public:
int x, y1; // no need to store y2
Vertical(int x, int y1) : x(x), y1(y1) {}
static bool comp(const Vertical & a, const Vertical & b)
{
return a.y1 < b.y1;
}
};
long long total = 0;
int vertI = 0; // index of next vertical to add to currentVerts
map<int, int> currentVerts; // currentVerts[5] = y1 of the vert line with x=5
vector<Vertical> verticals;
vector<Horizontal> horizontals;
vector<int> solutions;
void readInput();
void processHorizontal(Horizontal & line);
int main()
{
cout.precision(10);
readInput();
sort(verticals.begin(), verticals.end(), Vertical::comp);
sort(horizontals.begin(), horizontals.end(), Horizontal::comp);
// process the lines (start at i = 1 to ignore the top one)
for (int i = 1; i < horizontals.size(); i++)
{
processHorizontal(horizontals[i]);
}
sort(solutions.begin(), solutions.end());
for (int i = solutions.size() - 1; i >= 0; i--)
{
cout << (double) solutions[i] / total << "\n";
}
}
void readInput()
{
int n;
cin >> n;
int x1, x2, y1, y2;
for (int i = 0; i < n; i++)
{
cin >> x1 >> y1 >> x2 >> y2;
if (x2 < x1) swap(x1, x2);
if (y2 < y1) swap(y1, y2);
if (x1 == x2) verticals.push_back(Vertical(x1, y1));
else horizontals.push_back(Horizontal(x1, x2, y1));
}
}
void processHorizontal(Horizontal & horiz)
{
// add all vert lines which start above horiz to currentVert
for ( ; vertI < verticals.size() && verticals[vertI].y1 < horiz.y;
vertI++)
{
int x = verticals[vertI].x;
currentVerts[x] = verticals[vertI].y1;
}
map<int, int>::iterator left = currentVerts.find(horiz.x1);
map<int, int>::iterator right = currentVerts.find(horiz.x2);
map<int, int>::iterator i;
map<int, int>::iterator next;
for (i = next = left; i != right; i = next)
{
next++;
int width = (*next).first - (*i).first; // difference in x
int height = horiz.y - (*i).second; // difference y
int area = width * height;
total += area;
solutions.push_back(area);
if (i != left)
{
// if i is not the start it must be a short
// line which ends here, so delete it
currentVerts.erase(i);
}
else
{
// if it is left, cut the rectangle at horiz.y
// by modifying the start of the line
(*i).second = horiz.y;
}
}
}