Looking back at the other algorithms that solved this problem I can
say with most confidence that the Branch and Bound solution is far
better than Backtracking, or Brute Force. All three types of my
algorithm's running type were bound by 
, and each of the
three algorithms displayed that measure empericily. The big
differnance between the three was the constants ignored by the
asymtotic analysis. The Brute Force algorithms all had the largest
constants, they had to actually look at each and every complete
soltion everytime, which would only happen in the worst case of the
other two algorithms. By looking at the number of tasks I could
schedule with each you can get a good idea of the differances in the
constants involved.
Obvousely Branch & Bound is better than the rest by far, but what are the costs. Branch and Bound needs a very large amount of storage space that can't be reduced or removed, the other two kinds needed very little space at all in comparison. Branch and Bound isn't guaranteed to give a schedule at all, very often it runs out of memory before it can output. Related the Branch and Bound algorithm is very sensitive to the input instance so you may be able to some schedules of a certain size and many others take to much memory to perform. You can't say for certain about how long its going to take to complete the scheduling like is possible with the other algorithms.
Branch and Bound is not all bad, certainly the speed is its greatest asset, but also it can be enhanced and experimented with more than the other algorithms. Things like finding better lower bound algorithms, preprocessing in other ways, pulling out of heap on more than one attribute of the partail schedule. Probably not all the ``bag of tricks'' will do good things, but they could be useful in special cases, such as the all tasks costs being the same. Interestingly that case I found to be one of the most difficult for the Backtracking algorithm to do, it required that it examine more of its nodes therefore taking more time than usual.
One thing that was an interesting chacteristic of the Backtracking algorithm was that the variance of the input intance effected the runtime of the program. I thought this might be the case with the Branch and Bound algorithm too, but after much testing I concluded that it wasn't true.