Подсчет узлов, сгенерированных в задаче ветвления и связанного ранца

Question

У меня есть ветвь и связанная с ней реализация проблемы ранца 0-1 в Java. Для моего задания мне нужно подсчитать количество узлов, сгенерированных в решении, но я не уверен, как это сделать.

Я знаю, что вы можете сосчитать узлы из односвязных списков, но я не уверен, как это сделать для списка с очередью. Вот мой код:

import java.io.*;
import java.util.*;

class node{
    int level;
    int weight;
    int profit;
    int bound;
}

public class knapsack{
    static Queue<node> Q = new LinkedList<node>();

        public static void main(String args[])throws Exception{
                int maxProfit;
                int N;
                int W;
                int weight;
                int value;
                int maxVal;

                Scanner input = new Scanner(System.in);

                System.out.println("Please enter the number of items: ");
                N = input.nextInt();
                System.out.println("Please enter the capacity of the Knapsack: ");
                W = input.nextInt();

                int[] Vl = new int[N];
                int[] Wt = new int[N];

                for(int i = 0; i < N; i++){
                        System.out.println("Please enter the weight anc value of item " + i + ": ");
                        weight = input.nextInt();
                        value = input.nextInt();

                        Wt[i] = weight;
                        Vl[i] = value;
                }


                        maxVal = knapsack3(N, Vl, Wt, W);


                System.out.println(maxVal);

        }


        public static int bound(node u, int n, int W, int[] pVa, int[] wVa){
                int j = 0, k = 0;
                int totweight = 0;
                int result = 0;

                if (u.weight >= W){
                        return 0;
                }
                else{
                        result = u.profit;
                        j = u.level + 1;
                        totweight = u.weight;

                        while ((j < n) && (totweight + wVa[j] <= W)){
                                totweight = totweight + wVa[j];
                                result = result + pVa[j];
                                j++;
                        }

                        k = j;

                        if (k < n){
                                result = result + (W - totweight) * pVa[k]/wVa[k];
                        }
                        return result;
                }
        }

        public static int knapsack3(int n, int[] p, int[] w, int W){
                node u = new node();
                node v = new node();
                int[] pNew = new int[p.length];
                int[] wNew = new int[w.length];
                Q.poll();

                for (int i = 0; i < n; i++){
                        pNew[i] = p[i];
                        wNew[i] = w[i];
                }

                v.level = -1;
                v.profit = 0;
                v.weight = 0;

                int maxProfit = 0;

                Q.add(v);

                while (Q.size() > 0){
                        v = Q.remove();

                        if (v.level == -1){
                                u.level = 0;
                        }
                        else if (v.level != (n - 1)){
                                u.level = v.level + 1;
                        }

                        u.weight = v.weight + w[u.level];
                        u.profit = v.profit + p[u.level];

                        u.bound = bound(u, n, W, pNew, wNew);

                        if (u.weight <= W && u.profit > maxProfit){
                                maxProfit = u.profit;
                        }

                        if (u.bound > maxProfit){
                                Q.add(u);
                        }



                }
                return maxProfit;
        }

}

Спасибо