Question

Let’s say i have some items, that have a defined length and horizontal position (both are constant) :

1 : A      
2 :     B
3 :  CC
4 :  DDD   (item 4 start at position 1, length = 3)
5 :    EE  
6 : F

I’d like to pack them vertically, resulting in a rectangle having smallest height as possible.

Until now, I have some very simple algorithm that loops over the items and that check row by row if placing them in that row is possible (that means without colliding with something else). Sometimes, it works perfectly (by chance) but sometimes, it results in non-optimal solution.

Here is what it would give for the above example (step by step) :

 A      |  A   B  |  ACC B  |  ACC B  |  ACC B  |  ACC B  | 
                                DDD   |   DDD   |  FDDD   |
                                            EE  |     EE  |

While optimal solution would be :

ADDDB 
FCCEE

Note : I have found that sorting items by their length (descending order) first, before applying algorithm, give better results (but it is still not perfect).

Is there any algorithm that would give me optimal solution in reasonable time ? (trying all possibilities is not feasible)

---

EDIT : here is an example that would not work using sorting trick and that would not work using what TylerOhlsen suggested (unless i dont understand his answer) :

1 : AA
2 :    BBB
3 :   CCC 
4 :  DD 

Would give :

AA BBB
  CCC 
 DD

Optimal solution :

 DDBBB
AACCC 

Answer 1

Just spitballing (off the top of my head and just pseudocode ). This algorithm is looping through positions of the current row and attempts to find the best item to place at the position and then moves on to the next row when this row completes. The algorithm completes when all items are used.

The key to the performance of this algorithm is creating an efficient method which finds the longest item at a specific position. This could be done by creating a dictionary (or hash table) of: key=positions, value=sorted list of items at that position (sorted by length descending). Then finding the longest item at a position is as simple as looking up the list of items by position from that hash table and popping the top item off that list.

int cursorRow = 0;
int cursorPosition = 0;
int maxRowLength = 5;

List<Item> items = //fill with item list
Item[][] result = new Item[][];

while (items.Count() > 0)
(
    Item item = FindLongestItemAtPosition(cursorPosition);
    if (item != null)
    {
        result[cursorRow][cursorPosition] = item;
        items.Remove(item);
        cursorPosition += item.Length;
    }
    else //No items remain with this position
    {
        cursorPosition++;
    }

    if (cursorPosition == maxRowLength)
    {
        cursorPosition = 0;
        cursorRow++;
    }
}

This should result in the following steps for Example 1 (at the beginning of each loop)…

 Row=0  |  Row=0  |  Row=0  |  Row=1  |  Row=1  |  Row=1  |  Row=2  |
 Pos=0  |  Pos=1  |  Pos=4  |  Pos=0  |  Pos=1  |  Pos=3  |  Pos=0  |

        |  A      |  ADDD   |  ADDDB  |  ADDDB  |  ADDDB  |  ADDDB  | 
                                         F      |  FCC    |  FCCEE  |

This should result in the following steps for Example 2 (at the beginning of each loop)…

 Row=0  |  Row=0   |  Row=0   |  Row=1   |  Row=1   |  Row=1   |  Row=2   |
 Pos=0  |  Pos=2   |  Pos=4   |  Pos=0   |  Pos=1   |  Pos=3   |  Pos=0   |

        |  AA      |  AACCC   |  AACCC   |  AACCC   |  AACCC   |  AACCC   |
                                                         DD    |   DDBBB  |