数据结构与算法之分支界线查找

分支界限查找（Branch and Bound）是一种常用的解决优化问题的算法。其基本思想是通过对问题的解空间进行剪枝，以快速减少搜索空间，从而获得最优解。

分支界限查找算法分为两个阶段：扩展阶段和界限阶段。在扩展阶段，我们按照某种策略生成问题的一部分解。然后，对于每个生成的解，我们计算出一个界限值（Lower Bound），并将这个界限值与当前的最优解进行比较。如果生成的解的界限值比当前最优解差，那么该解将被剪枝。如果生成的解的界限值比当前最优解好，那么我们将该解加入到候选解集合中，并更新最优解。在界限阶段，我们重复这个过程，直到找到最优解。

分支界限查找的基本思路很简单，但实际应用中需要考虑一些细节。其中最重要的就是如何计算界限值。对于不同类型的问题，界限值的计算方法也不同。这需要根据具体问题进行定制。此外，在扩展阶段，需要考虑如何生成解以及如何对解进行排序，以提高算法的效率。在界限阶段，需要设计合适的剪枝规则，以快速减少搜索空间。

总的来说，分支界限查找算法是一种非常灵活的方法，可以适用于各种不同类型的问题。但由于其需要设计合适的界限值计算方法和剪枝规则，所以实现起来比较困难。但如果能够设计好这些细节，分支界限查找算法可以在很多场景下取得非常好的效果。

---

一、C 分支界线查找 源码实现及详解

分支界线查找（Branch and Bound）是一种重要的组合优化算法，通常用于解决NP问题。其基本思想是通过剪枝策略，将搜索空间划分成若干个子集，从而达到减少搜索时间的目的。

算法流程：

1. 初始化一棵搜索树，将初始集合加入到根节点上，并将根节点加入到活节点列表中。
2. 从活节点列表中取出一个节点进行扩展。如果该节点的最优值大于当前全局最优值，则剪枝并返回到上一层节点；否则继续向下扩展。
3. 对于当前节点，找到其所有可行的子节点，并计算它们的最优值。将这些子节点加入到活节点列表中，并按照最优值的大小排序。
4. 重复步骤2和步骤3，直到所有节点都被扩展完毕。

C语言代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define MAX_SIZE 100

typedef struct {
    int value;  // 当前节点的价值
    int weight; // 当前节点的重量
    double bound; // 当前节点的上界
    int level; // 当前节点的层数
} NODE;

int max(int a, int b) {
    return a > b ? a : b;
}

double bound(NODE u, int n, int c, int *w, int *v) {
    if (u.weight >= c) {
        return 0;
    }
    double result = u.value;
    int j = u.level + 1;
    int totweight = u.weight;

    while (j < n && totweight + w[j] <= c) {
        totweight += w[j];
        result += v[j];
        j++;
    }

    if (j < n) {
        result += (c - totweight) * v[j] / w[j];
    }

    return result;
}

int knapsack(int n, int c, int *w, int *v) {
    int i;
    NODE u, v1;

    u.level = -1;
    u.value = u.weight = 0;
    double maxvalue = 0.0;
    int *bestx = (int *)malloc(sizeof(int) * n);

    for (i = 0; i < n; i++) {
        bestx[i] = 0;
    }

    u.bound = bound(u, n, c, w, v);
    NODE *queue = (NODE *)malloc(sizeof(NODE) * MAX_SIZE);
    int head = 0, tail = 0;

    while (1) {
        if (u.level == -1) {
            v1.level = 0;
        } else if (u.level == n - 1) {
            break;
        }

        v1.level = u.level + 1;
        v1.weight = u.weight + w[v1.level];
        v1.value = u.value + v[v1.level];

        if (v1.weight <= c && v1.value > maxvalue) {
            maxvalue = v1.value;
            bestx[v1.level] = 1;
        }

        v1.bound = bound(v1, n, c, w, v);

        if (v1.bound > maxvalue) {
            queue[tail++] = v1;
        }

        NODE v2 = u;

        v2.weight = u.weight;
        v2.value = u.value;
        v2.bound = bound(v2, n, c, w, v);

        if (v2.bound > maxvalue) {
            queue[tail++] = v2;
        }

        if (head == tail) {
            break;
        }

        u = queue[head++];
    }

    free(queue);
    free(bestx);
    return maxvalue;
}

int main() {
    int w[] = {2, 3, 4, 5};
    int v[] = {3, 4, 5, 6};
    int c = 8;
    int n = sizeof(w) / sizeof(w[0]);
    int maxvalue = knapsack(n, c, w, v);
    printf("Maximum value = %d\n", maxvalue);
    return 0;
}

算法分析：

分支界线查找算法的时间复杂度取决于搜索树的深度和宽度，因此算法的时间复杂度为O(b^{d)，其中b是每个节点的平均分支数，d是搜索树的深度。在最坏情况下，搜索树的深度可以达到n，因此算法的时间复杂度可以达到O(b}n)。由于此算法一般用于解决NP问题，因此通常情况下无法在有效的时间内找到最优解，但可以找到一个近似解。

---

二、C++ 分支界线查找 源码实现及详解

分支界限（Branch and Bound）是一种搜索算法，用于在最优化问题中找到全局最优解。它通过维护一个搜索树，并剪枝来获得更好的性能。

以下是一个C++实现的分支界限算法。我们将使用TSP（旅行商问题）作为示例问题。TSP是一个NP-hard问题，它要求找到一条遍历所有给定城市的最短路径。

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int INF = 1e9;

int n; // 城市数量
int dist[20][20]; // 城市距离矩阵
int best_dist = INF; // 最优路径长度
vector<int> path; // 最优路径

// 计算路径长度
int calculate_dist(const vector<int>& path) {
    int res = 0;
    for (int i = 1; i < n; ++i) {
        res += dist[path[i-1]][path[i]];
    }
    res += dist[path[n-1]][path[0]];
    return res;
}

// 分支界限算法
void branch_and_bound(int cur_dist, vector<int> cur_path) {
    // 如果当前路径长度已超过当前最优路径长度，则剪枝
    if (cur_dist >= best_dist) r