已知一个固定容量的背包c=8和3个物品，每个物品有其重量和价值，重量分别为（2，7，1），价值分别为（1，9，3）。如果每个物品只能拿1个或不拿，请利用优先队列式分支限界法求不超过背包容量的前提下可获得的最大价值，使用c++设计带注释剪枝函数

下面是使用C++实现的代码，其中包括了剪枝函数的注释。

#include <iostream>
#include <queue>
using namespace std;

// 物品结构体，包括重量和价值
struct Item {
    int weight;
    int value;
};

// 定义一个比较函数，用于优先队列排序
struct CompareItem {
    bool operator()(const Item& a, const Item& b) {
        return a.value < b.value;
    }
};

// 剪枝函数，返回当前节点的价值上界
int bound(int i, int w, int v, const vector<Item>& items, int c) {
    int val = v;  // 当前物品的总价值
    int wt = w;   // 当前物品的总重量
    int n = items.size();
    // 装满背包
    for (int j = i; j < n && wt + items[j].weight <= c; j++) {
        wt += items[j].weight;
        val += items[j].value;
    }
    // 如果背包未被装满，则装入下一个物品的一部分
    if (wt < c) {
        val += (c - wt) * items[i].value / items[i].weight;
    }
    return val;
}

// 分支限界法求解背包问题
int knapsack(const vector<Item>& items, int c) {
    // 初始化
    int n = items.size();
    int max_val = 0;
    priority_queue<Item, vector<Item>, CompareItem> pq;
    Item item;
    item.weight = 0;
    item.value = 0;
    pq.push(item);
    // 循环处理队列中的节点
    while (!pq.empty()) {
        Item node = pq.top();
        pq.pop();
        int i = node.weight;
        int v = node.value;
        if (i == n) {
            // 已经处理完所有物品，更新最大价值
            max_val = max(max_val, v);
        } else {
            // 如果可以装入当前物品，则分为装或不装两种情况
            if (i < n && v + items[i].value > max_val && node.weight + items[i].weight <= c) {
                Item left;
                left.weight = i + 1;
                left.value = v + items[i].value;
                pq.push(left);
            }
            if (i < n && bound(i + 1, node.weight, node.value, items, c) > max_val) {
                Item right;
                right.weight = i + 1;
                right.value = v;
                pq.push(right);
            }
        }
    }
    return max_val;
}

int main() {
    vector<Item> items{{2, 1}, {7, 9}, {1, 3}};
    int c = 8;
    int max_val = knapsack(items, c);
    cout << "Max value: " << max_val << endl;  // 输出最大价值
    return 0;
}

在剪枝函数`bound`中，我们首先对当前物品以后的所有物品进行贪心式装载，得到能够装入背包的最大价值。如果此时背包未被装满，则装入下一个物品的一部分，并计算其能够贡献的价值上界。该价值上界即为剪枝函数的返回值。

在主函数中，我们定义了一个优先队列，用于存储待处理的节点。每次从队列中取出一个节点，并根据其是否可行进行分支。如果可以装入当前物品，则将其装入或不装入两种情况分别加入队列；如果不能装入当前物品，则直接不装入，并计算其价值上界。如果当前节点已经处理完所有物品，则更新最大价值，并结束循环。

最终，输出得到的最大价值。