Question

I have to write an algorithm for Assigning Contiguous seats in a seat map.For example: allocating seats in a stadium. The seat map can be viewed as a 2d array of N rows and M columns. The system must assign contiguous seats for bookings that are made together. Since no seat map is presented to the user, the system should automatically assign the available seats corresponding to each purchase. In addition to this, it should do this in such a fashion such that the holes/gaps in the seats are minimized.

Answer 1

Finding a perfect solution is NP-hard. Look at the equivalent language problem:

L={((x1,x2,...,xk),n,m)} where xi are the number of co-booked tickets, and n,m are the stadium sizes.

We will show Partition <=(P) L, and thus this problem is NP-Hard, and there is no known polynomial solution for it.

Proof

let S=(x1,x2,..,xk) be the input for a partition problem, and let sum=x1+...+xk

Look at the following reduction:

Input: S=(x1,...,xk)
Output:((x1,...,xk),sum/2,2)

Correctness:
If S has a partition, let it be S1=(x_i1,x_i2,...,x_it), then by definition of partition, x_i1+...+x_it=sum/2, and thus we can insert x_i1,..,x_it in the first row, and the rest in the second row, and so ((x1,...,xk),sum/2,2) is in L

If ((x1,...,xk),sum/2,2) is in L, then by definition there are t bookings such that x_i1,x_i2,...,x_it form a perfect first line, and thus x_i1+x_i2+...+x_it=sum/2, and thus it is a valid partition and S is in Partition problem

Conclusion:

Since L is NP-Hard, and the problem you seek is the optimization problem for this language, there is no known polynomial solution for it. For an exact solution you can use backtracking [check all possibilities, and choose the best], but it will take a lot of time, or you can sattle for a heuristic solution, such as greedy, but it will not be optimized.

EDIT: Backtracking solution [pseudocode]:

solve(X,n,m):
   global bestVal <- infinity
   global bestSol <- null
   solve(X,new Solution(n,m))
solve(X,solution):
   if (X is empty):
       gaps <- solution.numGaps()
       if (gaps < bestVal):
            bestVal <- gaps
            bestSol <- solution
       return
   temp <- X.first
   X.removeFirst()
   for i from 0 to m:
       solution.addToLine(i,temp)
       solve(X,solution)
       solution.removeFromLine(i,temp)
   X.addFirst(temp)

Assuming Solution is an implemented class, and for an illegal solution [i.e. too many people in one row] numGaps() == infinity