问题描述
设某一机器由 n 个部件组成，每一种部件都可以从 m 个不同的供应商处购得。设 wij 是从供应商 j 处购得的部件 i 的重量， cij 是相应的价格。
设计一个优先队列式分支限界法，给出总价格不超过 d 的最小重量机器设计。
对于给定的机器部件重量和机器部件价格，设计一个优先队列式分支限界法，计算总价格不超过 d 的最小重量机器设计。
数据输入：
第一行有 3 个正整数 n ，m 和 d。接下来的 2n 行，每行 m 个数。前 n 行是 c，后 n 行是 w。
priority_queue用法
具体用法参照：priority_queue的用法，我仅讲解此次分支限界算法中使用的优先队列。
bool operator<(const node& a) const{//小根堆(返回true，则证明前者优先级低于后者，则后者居上！)
if (weigth!=a.weigth)
return weigth>a.weigth;//例：倘若weigth>a.weigth为真，则a的优先级更高，即weigth小的对象优先级更高！
else if(level!=a.level)
return a.level<level;
else
return num>a.num;
}在写这道算法之前，我对优先队列的印象只有这两个固定的用法：
大根堆：priority_queue<int> q;
小根堆：priority_queue<int, vector<int>, greater<int>> q;
但是，如你所见，这并不能满足分支限界法中对于优先队列的需求，我们必须自己定义优先函数，即在类或结构体中重载符号。本文的优先函数规定：重量小的节点优先度最高；倘若两者重量相同，则当前零件序号高者优先级更高（因为本题分层次树状结构进行遍历，每一层的节点为当前零件的m个供应商，每层确定一种零件，因此“零件序号高者”即为靠近叶子节点者）；倘若两者重量和当前遍历层数都相同，则供应商序号靠前者优先级更高。
若有疑问可留言，我会尽量及时答复。
Code(回溯法)
#include<bits/stdc++.h>
using namespace std;
int n, m, d, c[100][100], w[100][100], vis[100], ans = 0x3f3f3f, result[100];
void dfs(int cnt, int csum, int wsum) {
if (cnt == n) {
if (csum <= d && ans > wsum) {
ans = wsum;
for (int i = 0; i < n; i++)
result[i] = vis[i];
}
return;
}
for (int i = 0; i < m; i++) {
int t = vis[cnt];
if (csum <= d) {//价格剪枝
vis[cnt] = i;
dfs(cnt + 1, csum + c[cnt][i], wsum + w[cnt][i]);
vis[cnt] = t;
}
}
}
int main()
{
cin >> n >> m >> d;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> c[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> w[i][j];
dfs(0, 0, 0);
cout << ans << endl;
for (int i = 0; i < n; i++)
cout << result[i] + 1 << " ";
return 0;
}Code(分支限界法)
#include<bits/stdc++.h>
using namespace std;
int n, m, d, min_weigth=0x3f3f3f;
int ans[100];
int c[100][100], w[100][100];
struct node{
int weigth, cost, level, num, value[100];
node(int a, int b, int c, int d):weigth(a), cost(b), level(c), num(d){}
bool operator<(const node& a) const{//小根堆(返回true，则证明前者优先级低于后者，则后者居上！)
if (weigth!=a.weigth)
return weigth>a.weigth;//例：倘若weigth>a.weigth为true，则a的优先级更高，即weigth小的对象优先级更高！
else if(level!=a.level)
return a.level<level;
else
return num>a.num;
}
};
priority_queue<node> q;//小根堆
int main()
{
cin>>n>>m>>d;
for(int i=0;i<n;i++){//c
for(int j=0;j<m;j++){
cin>>c[i][j];
}
}
for(int i=0;i<n;i++){//w
for(int j=0;j<m;j++){
cin>>w[i][j];
}
}
for(int i=0;i<m;i++){//优先队列初始化
node temp=node(w[0][i], c[0][i], 0, i);
if(temp.cost>d)//剪枝（价格）
continue;
else{
temp.value[0]=i+1;
q.push(temp);
}
}
while(!q.empty()){
node temp=q.top();
q.pop();
if(temp.level<n-1){
for(int i=0;i<m;i++){
node t=node(temp.weigth+w[temp.level+1][i], temp.cost+c[temp.level+1][i], temp.level+1, i);
if(t.level==n-1){//到达叶子节点
if(t.weigth>min_weigth||t.cost>d)//剪枝（重量and价格）
continue;
else if(t.weigth<min_weigth){
min_weigth=t.weigth;//最小重量更新
for(int i=0;i<n-1;i++){//最优路径更新
ans[i]=temp.value[i];
}
ans[n-1]=i+1;
}
}
if(t.level<n-1){//非叶子节点
if(t.cost>d){//剪枝（价格）
continue;
}
else{
for(int i=0;i<t.level;i++)//历史路径
t.value[i]=temp.value[i];
t.value[t.level]=i+1;//路径更新
q.push(t);
}
}
}
}
}
cout<<min_weigth<<endl;
for(int i=0;i<n;i++){
cout<<ans[i]<<" ";
}
return 0;
}测试
输入：
3 3 4
1 2 3
3 2 1
2 2 2
1 2 3
3 2 1
2 2 2
输出：
4
1 3 1输入：
8 18 14
18 15 20 5 15 10 16 6 1 6 17 6 1 2 17 15 13 17
16 6 7 4 7 2 11 6 18 4 13 12 8 5 2 8 15 14
12 6 19 10 13 8 2 10 16 4 15 15 16 13 17 12 14 4
18 18 2 13 15 19 5 12 18 7 13 9 8 17 10 13 15 11
8 5 14 11 18 20 17 3 11 17 13 11 4 9 17 14 19 1
10 7 8 11 13 3 19 3 12 11 12 14 4 2 12 10 14 15
12 9 13 9 16 17 12 15 6 3 11 17 13 17 14 13 4 4
19 12 3 19 3 20 19 12 8 19 8 10 19 20 3 1 7 1
16 12 4 16 2 6 15 1 13 3 7 16 5 3 16 16 14 19
12 14 6 2 11 15 9 17 15 16 19 20 14 14 20 9 4 4
6 13 16 6 3 12 12 19 11 20 4 13 9 18 7 17 8 1
4 17 3 20 3 8 12 7 4 12 6 12 1 18 13 20 20 8
4 15 1 10 2 12 8 11 5 4 20 13 12 20 1 3 3 11
1 9 2 1 16 1 12 4 5 2 7 15 12 3 9 4 13 6
13 1 10 8 5 13 20 10 6 4 8 15 8 8 20 11 9 9
2 10 11 1 18 8 20 11 18 2 3 6 14 16 19 4 3 15
输出：
57
13 6 7 3 18 14 10 16