7. A heuristic for Solving MINLP
To analyze the complexity of B&B algorithm, the number of nodes checked is counted and expressed as a function of N, the number of integers in the MINLP problem. It can be shown that, for a multi-stage supply chain system under consideration, the complexity of the B&B algorithm is (NN+1 − 1)/(N − 1) ≈ O(NN). The worst case of the B&B algorithm may be this type of exponential form. As N becomes bigger, the computing time will soon be intractable. The algorithm needs to be modified to ease the computing complexity. A simple modification of this algorithm may result in reduction of the number of nodes being evaluated and the reduction in complexity; but, unfortunately, guaranteeing no optimality of the solution. For a large MINLP problem, although this kind of heuristics is not an optimal algorithm, sometime it is very helpful to obtain the satisfactory results.
In a node-tree of B&B algorithm, there are 1 + N levels where in the second level, there are 2N nodes that descend from the root node. These 2N nodes are all checked and sorted out in increasing order. The next search restarts from the first node (the smallest value) of the sorted nodes, which, in turn, leads to the third level with 2N − 2 children. Again, these 2N − 2 nodes are checked and sorted in increasing order, and so on so forth until the search procedure reaches to the bottom level where there are two nodes need to be checked. The smaller number of these two nodes is the final result of this heuristic. If the nodes in a level are infeasible, backtracking to the up level is performed and the search restarts from the next smallest node, and so on. The search is continued to the bottom level as long as the solution is feasible, potential and final. The complexity of the best case of this heuristic is 1 + 2N + (2N − 2) + (2N − 4) + (2N − 6) + ⋯ + 6 + 4 + 2 = 1 + (N − 1)N = O(N2). Also, once an integer solution is obtained in any node at any level, the procedure stops and the integer solution is the final result. The procedure is illustrated by a MINLP problem with N = 3, which is shown in Fig. 8.