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

首先，我们可以用一个结构体来表示每个物品，包括重量和价值：

struct Item {
    int weight;
    int value;
};

然后，我们可以定义一个优先队列，用于存储节点：

priority_queue<Node> pq;

其中，`Node`结构体中包含了当前节点的信息，包括当前已经选取的物品价值、剩余容量、当前已经选取的物品重量和下一个要考虑的物品编号：

struct Node {
    int value;
    int capacity;
    int weight;
    int index;
};

接下来，我们定义一个剪枝函数`bound()`，用于计算当前节点的上界。具体来说，我们可以先按照单位重量价值从大到小排序，然后依次选取物品，直到背包装满为止，记录已经选取的物品的价值之和，再加上剩余容量可以装下的最大单位重量价值的物品的价值，就是当前节点的上界：

int bound(Node node, vector<Item>& items) {
    int bound = node.value;
    int capacity = node.capacity;
    int index = node.index;
    int n = items.size();
    vector<pair<double, int>> unitValues(n);
    for (int i = 0; i < n; i++) {
        unitValues[i] = {1.0 * items[i].value / items[i].weight, i};
    }
    sort(unitValues.rbegin(), unitValues.rend());
    for (int i = 0; i < n && capacity > 0; i++) {
        int j = unitValues[i].second;
        if (items[j].weight <= capacity) {
            bound += items[j].value;
            capacity -= items[j].weight;
        } else {
            bound += 1.0 * capacity * items[j].value / items[j].weight;
            capacity = 0;
        }
    }
    return bound;
}

最后，我们可以使用优先队列式分支限界法，依次扩展节点，直到队列为空，每次从队首取出一个节点，如果当前节点的上界比当前最优解小，则剪枝；否则，如果当前节点是一个叶子节点，则更新最优解；否则，对当前节点进行扩展，生成两个子节点，分别表示选择当前物品和不选择当前物品的情况，计算它们的上界并插入队列中：

int knapsack(int capacity, vector<Item>& items) {
    int n = items.size();
    priority_queue<Node> pq;
    Node root = {0, capacity, 0, 0};
    int bestValue = 0;
    pq.push(root);
    while (!pq.empty()) {
        Node node = pq.top();
        pq.pop();
        if (node.value + bound(node, items) <= bestValue) {
            continue;
        }
        if (node.index == n) {
            bestValue = max(bestValue, node.value);
        } else {
            int weight = items[node.index].weight;
            int value = items[node.index].value;
            if (node.capacity >= weight) {
                Node left = {node.value + value, node.capacity - weight, node.weight + weight, node.index + 1};
                pq.push(left);
            }
            Node right = {node.value, node.capacity, node.weight, node.index + 1};
            pq.push(right);
        }
    }
    return bestValue;
}

完整代码：