Maximize the area utilized by rectangles put in a circle - algorithm

Question

I have a circle which i need to fill with rectangles.Piled one over the other.The rectangles are available in specific sizes only.And we are also given the number of rectangles we must put.I need to get the set of rectangle lengths which cover the most area of the circle.For eg if the circle has a diameter of 100,rectangles of lengths [100,95,90,85,...15,10,5] can be put.I have tried using a brute force method by parsing through all the possible combinations.It yields good results when the numbers are small.Another algorithm i tried is to restrict the range of lengths which each rectangle occupies.Like the first rectangle will have a length of 95 or 90 to give the best result.But even this method is cumbersome when the number of rectangles to be put is really high.Here is how the rectangles are arranged
If the first rectangle has a length l,and diameter of circle is d,its thickness is sqrt(d2-l2).The thickness of second one if its length is k is sqrt(d2-k2)-sqrt(d2-l2).
Is there any algorithm so that i can go formulate the results.

Answer 1

Why should a brute-force-attack on this problem be difficult? You just need to put some effort in your calculation code and I'm sure it will work fine. It just has 19 levels at maximum. This shouldn't be too complicated and will give you the result within ... well, some hours, as I just found out. 19 levels will result in 3.3e17 calculations.
About the algorithm:
With one rectangle, you get the largest covered area when the rectangle is a square. I think that's very easy to understand. The corner of the square is at 45° from the circle center (assuming that horizontal is 0°, but that actually doesn't matter as the whole structre is point symmetric), the size is (0.707*diameter)^2 = 5000.
The closest to width 70.7 is 70. In general I suggest checking the number below (70) and above (75) the accurate result (70.7). The area of your rectangle is 70 * 71.41 = 4999. (But it would be nice to know, if the height also has to be a value out of your 5's-grid!)
Now it's getting more difficult and I hope I am right:
As I write this answer, it turns out, I am not right. :-( The rounded values have a higher result than the theoretical maximum. But I will post it regardless, maybe it helps to find the real answer.
When you have 2 rectangles, the largest area to cover should be when
the corners of rect1 are at 30° (and 150°, 210°, 330°), and
the corners of rect2 are at 60° (and 120°, 240°, 300°).
The sizes would be:
rect 1: 0.866*dia * 0.5 *dia = 4330
rect 2: 0.5 *dia * 0.866*dia = 4330 - minus the overlap =>> 0.5*0.36*dia^2 = 1830
sum: 6160
rounded to the 5's grid:
rect 1, #1) 85*52.86 = 4478
rect 2: #1) 50*(86.60-52.86) = 1696.2 #2) 55*(83.52-52.86) = 1696.1 #3) 45*(89.30-52.86) = 1648
sums: 6173.87 // 6173.75 // 6126
rect 1, #2) 90*43.59 = 3923
rect 2: #1) 50*(86.60-43.59) = 2151 #2) 55*(83.52-43.59) = 2196 #3) 45*(89.30-43.59) = 2057
sums: 6074 // 6119 // 5980
The winner is combination 1.1: rect1 = 85, rect2 = 50.
Due to using rounded values, you have to check each combination of upper and lower (and exact if it is on the grid) value of each rectangle, resulting in a maximum of 3^n checks if n is the number of rectangles (except n=1). A brute force is not nicer, but maybe easier. (And as found out and written above, it maybe will return better results, as this method is inaccurate).
EDIT 1:
The formula for 1 rectangle (which results in a square) is:
A = x * sqrt(D²-x²)
calculate the maximum using the derivative of A:
A' = D²-2x² / sqrt(D²-x²) = 0
You can also find it here: http://oregonstate.edu/instruct/mth251/cq/Stage8/Lesson/rectangle.html
The formula for 2 rectangles is:
A = f(x,y) = x * sqrt(D²-x²) + y * [sqrt(D²-y²)-sqrt(D²-x²)]
( x = width of r1, y = width of r2 )
The formula for n rectangles depends on n unknown variables. So you need to calculate n partial derivatives. Have fun! (or consider brute force, as you already are given a grid and don't need to do iterations ;-) )

Answer 2

Brute force algorithm
amount of calculations:
levels calculations
1 19
2 19 + 19*18 = 361
...
5 19 + 19*18 + 19*18*17 + 19*18*17*16 + 19*18*17*16*15 = 1494559
...
10 3.7e11
15 6.3e15
19 3.3e19
C# (or C++):
double dDia = 100;
int nSizes = 20;
int nmax = 2; // number of rectangles
int main()
{
int n = 1;
double dArea = 0.0;
dArea = CalcMaxArea (n, 0);
}
double CalcMaxArea (int n, double dSizeYParent)
{
double dArea = 0.0;
double dAreaMax = 0.0;
for (int iRun = nSizes-n; iRun >= 1; iRun--)
{
double dSizeX = iRun * 5;
double dSizeY = Math.Sqrt(dDia * dDia - dSizeX * dSizeX) - dSizeYParent);
double dAreaThis = dSizeX * dSizeY;
double dAreaOthers = 0.0;
if (n < nmax)
dAreaOthers = CalcMaxArea (n+1, dSizeY);
if (dArea > dAreaMax)
dAreaMax = dArea;
}
}
VBA, to be used in MS Excel
Dim dDia As Double
Dim nmax As Integer
Dim nSizes As Integer
Sub main()
dDia = 100
nmax = 2
nSizes = 20
Dim n As Integer
Dim dArea As Double
n = 1
dArea = CalcMaxArea(n, 0)
End Sub
Function CalcMaxArea(n As Integer, dSizeYParent As Double) As Double
Dim dArea As Double
Dim dAreaMax As Double
dArea = 0
For iRun = nSizes - n To 1 Step -1
Dim dSizeX As Double
Dim dSizeY As Double
Dim dAreaThis As Double
Dim dAreaOthers As Double
dSizeX = iRun * 5
dSizeY = Sqr(dDia * dDia - dSizeX * dSizeX) - dSizeYParent
dAreaThis = dSizeX * dSizeY
dAreaOthers = 0
If n < nmax Then
dAreaOthers = CalcMaxArea(n + 1, dSizeY)
End If
dArea = dAreaThis + dAreaOthers
If dArea > dAreaMax Then
dAreaMax = dArea
End If
Next
CalcMaxArea = dAreaMax
End Function
Tested in VBA with the given values, got the same result: 6173.87.
Further code may be added to remember on which values the maximum as reached.

Answer 3

I read the question again, and realize I completely missed a couple of key points in your post. The picture confused me, but that isn't a good excuse. My previous suggestion in the comments was a completely bad idea. I'm sorry, and I hope you didn't send a lot of time looking into it. If I had to solve this problem, this is how I would do it, right or wrong.
So I have been thinking this problem over. The best solution I can think of is to use a search algorithm such as A*. A* its self it rather simple to implement. I'm assuming you already have a method to calculate the area, which to me seems the hardest part. I have an idea of how I would go on with calculating the area of overlapping rectangles, but its the reason why I didn't write a program that could prove that my suggestion is a good one.
What I would do is have a master list of all of the potential rectangles.
Add to your frontier a copy of all rectangles not in the current path as the nth rectangle placed. This will allow you to set the width, and therefore calculate the area of the circle left to be filled. Keeping doing this, selecting the lowest cost path from the frontier each time, and after m nodes are explored, you should have the best fit. Where m is the total number of rectangles you must place.
For the cost evaluation, using the amount of space left to fill seems a natural choice. One thing to make note of though, is that the area left decreases over time, and you will need one that increases. I would think dividing the area left by the number of rectangles left should give you a nice cost function for finding the lowest cost path to the least area left in the circle. That one sounded good to me, but i'm sure there are others that could be used.
In regards to the heuristic, without a heuristic function you still have a best first search, so I would expect it to perform better than a blind brute force technique. With a good heuristic function, I would expect the performance to increase significantly. In thinking about what would make a good heuristic function, I thought that estimating the amount of the circle the rectangle would fill might work well. For instance, 10% of the area of the rectangle divided by the number of rectangles left to be placed. Since there is no pre-determined goal state, any estimate would have to be base solely off the area of the next rectangle. We know the full area of the rectangle won't contribute to solution. The majority of every rectangle after the first is wasted space as far as the solution goes, which is how i came up with that heuristic. As with the cost function, it seems like a reasonable idea to me, but if anyone can think of a better one, all the better.
There are all sorts of sites on A* out there, but here is one that looks well written. http://web.mit.edu/eranki/www/tutorials/search/
I hope this helps you out.

Answer 4

I know devising a working algorithm is complex, but this is the approach I thought of :
There could be only one rectangle which can occupy the maximum area in the circle with given diameter.
Find out the the Max width and height of rectangle that can be made to fit into the circle. There are a lot of solutions for the same. For example look: Find Largest Inscribed Rectangle This rectangle will then conclude a major portion of the max area.
The next task is then to fill the remaining portion of the circle with the rectangle of different sizes. Find out the best fit rectangle, as in the below image. This can be done by checking if the circle points lie inside the rectangle for a specified height and width
I again agree that this is very difficult to implement.