写出0-1背包问题的回溯算法与分支限界法的问题分析、建模、算法描述、C++算法和算法分析

问题分析：
0-1背包问题是一个经典的组合优化问题，要求在一个给定的背包容量下，选择若干个物品放入背包中，使得物品的总价值最大，并且每个物品只能选择放入或不放入背包中。

建模：
我们可以将物品表示为一个二元组(w, v)，其中w表示物品的重量，v表示物品的价值。我们需要考虑以下几个问题：
1.如何选择物品放入背包中，使得价值最大？
2.如何在选择物品的过程中，保证不超过背包的容量？
3.如何回溯到上一个状态，寻找下一个可行解？

算法描述：
回溯算法：
1.初始化背包容量为0，从第一个物品开始遍历，每个物品有两种选择：放入或不放入背包中。
2.如果放入该物品后不超过背包容量，则将该物品的价值加入总价值中，并继续遍历下一个物品。
3.如果不放该物品，则直接跳过该物品，继续遍历下一个物品。
4.当遍历完所有物品后，保存当前的总价值，并回溯到上一个状态，寻找下一个可行解。
5.重复以上步骤，直到找到所有的可行解。

分支限界法：
1.将物品按照单位重量价值从大到小排序，并按照排序后的顺序遍历。
2.对于每个物品，有两种选择：放入或不放入背包中。分别计算放入和不放入的上界，选择上界更高的分支进行扩展。
3.如果上界小于当前最优解，则剪枝。
4.重复以上步骤，直到找到最优解或者所有分支都被剪枝。

C++算法实现：
回溯算法：

void backtrack(vector<int>& weights, vector<int>& values, int capacity, int cur_weight, int cur_value, int start, int& max_value) {
    if (cur_weight > capacity) return; // 如果超过背包容量，返回
    if (start == weights.size()) { // 遍历完所有物品
        max_value = max(max_value, cur_value); // 更新最大价值
        return;
    }
    backtrack(weights, values, capacity, cur_weight + weights[start], cur_value + values[start], start + 1, max_value); // 放入该物品
    backtrack(weights, values, capacity, cur_weight, cur_value, start + 1, max_value); // 不放该物品
}

int knapsack(vector<int>& weights, vector<int>& values, int capacity) {
    int max_value = 0;
    backtrack(weights, values, capacity, 0, 0, 0, max_value);
    return max_value;
}

分支限界法：

struct Node {
    int level; // 当前扩展到的层数
    int value; // 当前价值
    int weight; // 当前重量
    double bound; // 当前上界
};

struct cmp {
    bool operator() (const Node& a, const Node& b) {
        return a.bound < b.bound;
    }
};

double knapsack(vector<int>& weights, vector<int>& values, int capacity) {
    int n = weights.size();
    vector<int> indices(n);
    for (int i = 0; i < n; ++i) {
        indices[i] = i;
    }
    sort(indices.begin(), indices.end(), [&](int a, int b) {
        return (double)values[a] / weights[a] > (double)values[b] / weights[b];
    }); // 按照单位重量价值从大到小排序
    priority_queue<Node, vector<Node>, cmp> q;
    q.push({-1, 0, 0, 0}); // 将根节点入队
    double max_value = 0;
    while (!q.empty()) {
        auto u = q.top(); q.pop();
        if (u.bound < max_value) continue; // 如果上界小于当前最优解，则剪枝
        if (u.level == n - 1) { // 扩展到叶子节点
            max_value = max(max_value, (double)u.value);
            continue;
        }
        int i = indices[u.level + 1];
        if (u.weight + weights[i] <= capacity) { // 放入该物品
            q.push({u.level + 1, u.value + values[i], u.weight + weights[i], u.bound});
        }
        double bound = u.value + (double)(capacity - u.weight) * values[i] / weights[i]; // 计算不放该物品的上界
        if (bound > max_value) { // 如果上界大于当前最优解，则继续扩展
            q.push({u.level + 1, u.value, u.weight, bound});
        }
    }
    return max_value;
}

算法分析：
回溯算法的时间复杂度是指数级别的，空间复杂度是O(n)，其中n是物品个数。

分支限界法的时间复杂度是O(2^nlogn)，空间复杂度是O(n)，其中n是物品个数。虽然分支限界法的时间复杂度比回溯算法要低，但是在实际应用中，由于需要排序，因此常数较大，所以实际运行时间并不一定比回溯算法快。