Procedure B&B()
begin
    E: nodepointer;
    E := new(node);	-- this is the root node which 
			-- is the dummy start node 
    H: heap;		-- A heap for all the live nodes
    -- H is a min-heap for minimization problems,
    -- and a max-heap for maximization problems.
   while (true) do 
      if (E is a final leaf) then
         -- E is an optimal solution
         print out the path from E to the root;
         return;
      endif
      Expand(E);
      if (H is empty) then
	report that there is no solution;
	return;
      endif
      E := delete-top(H);	
   endwhile
end

Procedure Expand(E)
begin
  - Generate all the children of E;
  - Compute the approximate cost value CC of each child;
  - Insert each child into the heap H;
end

Branch and bound steps for our example:

1. The solution will be an array X[1:5] where each X[i] will indicate the inclusion or exclusion of a given object.
2. As a predictor CC, we need an estimated cost that is >= than the real one. For this, we could use a naïve approach: Based on the one we would pick if we were using the Greedy Method and if fractional knapsack was allowed. In other words, the best ratio of value-per-unit-weight r=v/w
3. To do so, we first sort the items by decreasing ratio of v/w: C(50.5 = 100/1.98), A(20 = 40/2), D(19 = 95/5), B(15.92 = 50/3.14), E(10 = 30/3), giving us the set array S: {C, A, D, B, E} with r values of {50.5, 20, 19, 15.92, 10}
4. A solution X would represent an inclusion array in the order defined by S, so for X: {0,1,1,0,1} would indicate: C excluded, A included, D included, B excluded, E included (with a profit of 40+95+30 = 165)
5. In terms of profit, if we were to choose in the order defined by S:{C, A, D, B, E}, the maximum possible profit (without the W limit) would be, sum(C to E) = 315; sum(A to E) = 215, sum(D to E) = 175; sum(B to E) = 80; sum(E) = 30
6. Now, we use the following CC predictor:

   CC(X at value k) = profit_so_far + fractional_knapsack_profit_{i=k+1 to n}S[i]

Now, for the algorithm steps, we do the following:

1. We first initialize the max-heap H with a dummy node E
2. Since E is not a terminal node, we can expand it to include the first choices: C in (X_k=1:{1}) or C out, C (X_k=1:{0})
3. The CC(X_k=1:{1}) = 0 + fractional_knapsack_profit_{i=1 to n}S[i] = 251.24 :
   • which accumulates as [ profit, total weight]:
   • → add C → [100, 1.98] → add A → [140, 3.98] → add D → [235, 8.98] → add [1.02 units of B] →
   • = [235, 8.98] → [235 + 1.02*15.92, 10] = [251.24, 10]
4. The CC(X_k=1:{0}) = 0 + fractional_knapsack_profit_{i=2 to n}S[i] = 182.76 :
   • which accumulates as [ profit, total weight]:
   • → don't add C → [0, 0] → add A → [40, 2] → add D → [135, 7] → add [3.0 units of B] →
   • = [135, 7] → [135 + 3.0*15.92, 10] = [182.76, 10]
5. We get the node from the max heap E (C in, or X_k=1:{1} ). Since the live node E is not a terminal node, we can expand it to include the next choices: A or A
6. The CC(X_k=2:{1,1}) = 100 + fractional_knapsack_profit_{i=2 to n}S[i] = 100 + 151.24 = 251.24 :
   → add A → [40, 3.98] → add D → [135, 8.98] → add [1.02 units of B] → [135 + 1.02*15.92, 10] = [151.24, 10]
7. The CC(X_k=2:{1,0}) = 100 + fractional_knapsack_profit_{i=3 to n}S[i] = 100 + 143.08 = 243.08 :
   → don't add A → [0, 1.98] → add D → [95, 6.98] → add [3.02 units of B] → [95 + 3.02*15.92, 10] = [143.08, 10]
8. We get the node from the max heap E (X_k=2:{1,1}). Since the live node E is not a terminal node, we can expand it to include the next choices: D or D
9. The CC(X_k=3:{1,1,1}) = 140 + fractional_knapsack_profit_{i=3 to n}S[i] = 140 + 111.24 = 218.8 :
   → add D → [95, 8.98] → add [1.02 units of B] → [95 + 1.02*15.92, 10] = [111.24, 10]
10. The CC(X_k=3:{1,1,0}) = 140 + fractional_knapsack_profit_{i=4 to n}S[i] = 140 + 78.8 = 178.8 :
    → don't add D → [0, 3.98] → add B → [50, 7.12] → add [2.88 units of E] → [50 + 2.88*10, 10] = [78.8, 10]

Continue the process!!