Algorigmic Effeciency:

Step 1 : reading file, entering into backpack, processing
 		(n dependent - linear)
		(the pqueue insert takes nlogn time actually, but as the
		comparator is null, logn approaches 1.)

Worst case:
In the _worst_ case scenario, there is no sum of the items that will yield
the requested weight. In addition, in the worst case, no trees will be removed
due to overflow. 
	Therefore, two of the three major advantages to the branch-and-bound algo 
	(as implemented here), the early removal and the 'pruner' are both useless
	in the WORST case. (while it has no effect, the internal pqueue that keeps
	the most likely prospects at the top of the queue still functions).
	The worst case is 2^n complexity, same as that of an exhaustive search.

Outside the worst case, we have to note that the result time isn't dependent
on the input set size alone. In addition, the expected number of elements 
that would be needed to fill the crate is an important factor that we will call
k. In actuality, it is a combination of k and n that lead to our complexity. 
K is not precisely determined but can be found nominally by 
k= (max pallet size)/(avg input mass)

This indirectly points to the condition in the worst case scenario --- 
if k > n, there can be no solution. (this is trapped directly)
if the difference between k and n is small, a great number of trees will need 
 to be created to find the solutions
if k << n, the solution is easily arrived at.

So, if k !< n, trees will be removed due to overflow. There is a dependence
	upon k here. (well k/n to be sure). 

Also:
if every element of n is greater than the palette size, there can be no sol.

	
Additionally, if there is one or more solutions, they may be detected early.
	The entire state tree (minus prunes) doesn't have to be drawn, as we are
	looking for _any_ set.
	
Finally, there is a depedence upon the input set n - beyond the input times
	at the beginning there is also a 2^n increase in the _possilble_ set size,
	the three aforementioned tools goal is to reduce that set size dramatically.
	
	
Everything aside though, the complexity is defined (at least in big O notation)
by the worst case scenario, --- for this problem as a whole (whether via 
brute search or branch-bound) the O notation is O(2^n)			


-Rizwan Kassim