分支定界

分支定界法的目的是从可行解集合${\displaystyle S}$中选出一个解${\displaystyle x}$，使得目标函数${\displaystyle f(x)}$最大化或最小化。其中集合${\displaystyle S}$被称为搜寻空间或可行区域。本节所有的最佳化问题均可视为对${\displaystyle f(x)}$进行最小化，因为对${\displaystyle f(x)}$进行最大化问题本质上还是对${\displaystyle g(x)=-f(x)}$进行最小化。分支定界法需要遵循以下两个原则：

• 先是将搜寻空间通过递归的手段分成多个子空间，在每个子空间对${\displaystyle f(x)}$进行最小化，这种分割方式就是分支。
• 如果只有分支那么这种方法就成为了暴力搜索法，运算量将会非常庞大。为了提升算法的性能，需要对每个分支进行下界计算，对于那些下界已经超过目前最佳解的分支，需要进行剪枝操作。

为了将这些原则转化为问题的具体算法，我们需要将这些候选解转化为合适的数据结构，这样的表示方式被称为问题的实例。我们用${\displaystyle S_{I}}$表示实例${\displaystyle I}$的候选解集，实例表示必须有如下三个操作:

• ${\displaystyle branch(I)}$：产生两个或多个实例，每个实例为${\displaystyle S_{I}}$的一个子集。（通常来讲，每个子集都是互不相交的，这是为了避免每个候选解被多次访问从而浪费时间，但有时也会有例外。${\displaystyle S_{I}}$的最优解必然会出现在它的一个或多个子集中。[5]）
• ${\displaystyle bound(I)}$：计算实例${\displaystyle I}$中所有候选解所对应的目标函数值的下界，满足对于任意${\displaystyle x\in S_{I}}$，${\displaystyle bound(I)\leq f(x)}$。
• ${\displaystyle solution(I)}$：确定${\displaystyle I}$是否表示单个候选解。（如果不是，接下来可以从${\displaystyle S_{I}}$中回传一些可行的解再进一步进行分支定界的操作。[5]）如果${\displaystyle solution(I)}$回传了一个解，那么${\displaystyle f(solution(I))}$提供了整个可行解空间中最优目标函数的上界。

通过使用这些操作，分支定界算法在分支操作形成的实例树中执行自顶向下递归搜索。在访问实例${\displaystyle I}$时，我们不妨先检查${\displaystyle bound(I)}$，如果${\displaystyle bound(I)}$已经大于目前所找到的上界，我们就直接丢弃该实例。为了实现这一步骤，我们需要设定一个全局变量，用于记录目前为止所检查的所有实例中看到的最小上界。

// C++-like implementation of branch and bound, 
// assuming the objective function f is to be minimized
CombinatorialSolution branch_and_bound_solve(
    CombinatorialProblem problem, 
    ObjectiveFunction objective_function /*f*/,
    BoundingFunction lower_bound_function /*bound*/) 
{
    // Step 1 above
    double problem_upper_bound = std::numeric_limits<double>::infinity; // = B
    CombinatorialSolution heuristic_solution = heuristic_solve(problem); // x_h
    problem_upper_bound = objective_function(heuristic_solution); // B = f(x_h)
    CombinatorialSolution current_optimum = heuristic_solution;
    // Step 2 above
    queue<CandidateSolutionTree> candidate_queue;
    // problem-specific queue initialization
    candidate_queue = populate_candidates(problem);
    while (!candidate_queue.empty()) { // Step 3 above
        // Step 3.1
        CandidateSolutionTree node = candidate_queue.pop();
        // "node" represents N above
        if (node.represents_single_candidate()) { // Step 3.2
            if (objective_function(node.candidate()) < problem_upper_bound) {
                current_optimum = node.candidate();
                problem_upper_bound = objective_function(current_optimum);
            }
            // else, node is a single candidate which is not optimum
        }
        else { // Step 3.3: node represents a branch of candidate solutions
            // "child_branch" represents N_i above
            for (auto&& child_branch : node.candidate_nodes) {
                if (lower_bound_function(child_branch) <= problem_upper_bound) {
                    candidate_queue.enqueue(child_branch); // Step 3.3.2
                }
                // otherwise, bound(N_i) > B so we prune the branch; step 3.3.1
            }
        }
    }
    return current_optimum;
}