【回溯算法】最小重量机器设计问题

算法实现题 5-3 最小重量机器设计问题

问题描述:设某一机器由n个部件组成,每一种部件都可以从m个不同的供应商处购得。设wij是从供应商j处购来的部件i的重量,cij是相应的价格。
试设计一个算法,给出总价格不超过c的最小重量机器设计。
算法设计:对于给定的机器部件重量和机器部件价格,计算总价值不超过d的最小重量机器设计。

数据输入:第一行由3个正整数n,m,d。接下来的2n行,每行m个数。前n行是c,后n行是w。
结果输出:将计算的最小重量及每个部件的供应商输出。

输入:
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
 

参考链接

https://blog.csdn.net/IOIO_/article/details/81093152

这种方法一般找到的都是第一个出现的解。有的时候第一个出现的解不一定是最优的,但是也要采取。

通过样例我们可以发现,其实1 3 2 或者 1 3 3 都是符合题目的要求的,而且最优情况也和 1 3 1 相同,但是由于他们按照代码的循环来找,找到之后就不再继续进行了,所以只有一个解。

最新版

#include<bits/stdc++.h>
using namespace std;

int n,m,d;//n个组件 m个供应商 总价格不超过d
int c[999][999],w[999][999];//c[i][j],w[i][j] 各表示从供应商j处购得部件i的价格/重量
int cw=0,cp=0;//记录当前最小的重量和价值
int bestw=999,bestp=999;//最小重量
int x[999],bestx[999];//保存当前重量下每个部件供应商的号码

void backtrack(int i) {
	if(i>n) {
		if(cp<=d&&cw<bestw) { //条件更优时,更新数据
			bestw=cw;
			bestp=cp;
			for(int j=1; j<=n; j++)
				bestx[j]=x[j];
		}

	} else {
		for(int j=1; j<=m; j++) {
			x[i]=j;//记录下当前部件是哪一个供应商
			cw=cw+w[i][j];
			cp=cp+c[i][j];
			if(cp<=d&&cw<bestw) {//剪枝
				//如果当前供应商的部件可以满足条件 直接进入下一个部件的判断
				backtrack(i+1);
			}
			//回溯过程
			cw=cw-w[i][j];
			cp=cp-c[i][j];
		}
	}
}

int main() {
	cin>>n>>m>>d;

	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>c[i][j];

	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>w[i][j];

	backtrack(1);
	cout<<bestw<<endl;
	for(int i=1; i<=n; i++)
		cout<<bestx[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
*/

版本一 

#include<bits/stdc++.h>
using namespace std;

int n,m,d;//n个组件 m个供应商 总价格不超过d
int c[999][999],w[999][999];//c[i][j],w[i][j] 各表示从供应商j处购得部件i的价格/重量
int cw=0,cp=0;//记录当前最小的重量和价值 
int bestw=999;//最小重量 
int x[999],bestx[999];//保存当前重量下每个部件供应商的号码 

bool backtrack(int i) {
	if(i>n) {
		bestw=cw;
		for(int j=1; j<=n; j++)
			bestx[j]=x[j];
		return true;
	}
	bool find=false;
	if(bestw<=d)
		find=true;
	for(int j=1; j<=m; j++) {
		x[i]=j;//记录下当前部件是哪一个供应商 
		cw=cw+w[i][j];
		cp=cp+c[i][j];
		if(cp<=d&&cw<bestw) {//如果当前供应商的部件可以满足条件 直接进入下一个部件的判断 
			if(backtrack(i+1))
				find=true;
		}
		//回溯过程 
		cw=cw-w[i][j];
		cp=cp-c[i][j];
	}
	return find;
}

int main() {
	cin>>n>>m>>d;

	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>c[i][j];

	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>w[i][j];

	if(backtrack(1)) {
		cout<<bestw<<endl;
		for(int i=1; i<=n; i++)
			cout<<bestx[i]<<" ";
	}

	return 0;
}

版本二

#include<bits/stdc++.h>
using namespace std;

int n,m,d;//n个组件 m个供应商 总价格不超过d
int c[999][999],w[999][999];//c[i][j],w[i][j] 各表示从供应商j处购得部件i的价格/重量
int cw=0,cp=0;//记录当前最小的重量和价值
int bestw=999;//最小重量
int x[999],bestx[999];//保存当前重量下每个部件供应商的号码

void backtrack(int i) {
	if(i>n) {
		bestw=cw;
		for(int j=1; j<=n; j++)
			bestx[j]=x[j];
	}

	for(int j=1; j<=m; j++) {
		x[i]=j;//记录下当前部件是哪一个供应商
		cw=cw+w[i][j];
		cp=cp+c[i][j];
		if(cp<=d&&cw<bestw) {//如果当前供应商的部件可以满足条件 直接进入下一个部件的判断
			backtrack(i+1);
		}
		//回溯过程
		cw=cw-w[i][j];
		cp=cp-c[i][j];
	}
}

int main() {
	cin>>n>>m>>d;

	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>c[i][j];

	for(int i=1; i<=n; i++)
		for(int j=1; j<=m; j++)
			cin>>w[i][j];

	backtrack(1);
	cout<<bestw<<endl;
	for(int i=1; i<=n; i++)
		cout<<bestx[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
*/


 

最小重量机器设计问题一种典型的组合优化问题,可以使用回溯算法来实现。下面是一种基于回溯算法最小重量机器设计问题的C++实现: ```c++ #include <iostream> #include <cstring> #include <algorithm> using namespace std; const int MAXN = 20; int n, m; // n个零件,m个机器 int w[MAXN]; // 每个零件的重量 int a[MAXN]; // 每个零件的分配机器编号 int ans = 0x3f3f3f3f; // 当前最小重量 void dfs(int cur, int sum) { // cur表示当前处理的零件编号,sum表示当前的总重量 if (cur == n) { // 如果所有零件都已经处理完毕 ans = min(ans, sum); // 更新最小重量 return; } if (sum >= ans) { // 如果当前分配方案的总重量已经大于当前最小重量,则可以剪枝,退出当前分配方案 return; } for (int i = 0; i < m; i++) { // 枚举所有机器 a[cur] = i; // 将当前零件分配给第i台机器 dfs(cur+1, sum+w[cur]); // 处理下一个零件 a[cur] = -1; // 回溯,撤销当前零件的分配方案 } } int main() { cin >> n >> m; for (int i = 0; i < n; i++) { cin >> w[i]; } memset(a, -1, sizeof(a)); // 初始化所有零件都没有分配机器 dfs(0, 0); // 从第一个零件开始处理 cout << ans << endl; // 输出最小重量 return 0; } ``` 在这段代码中,我们定义了一个`dfs`函数,用于实现回溯算法。在该函数中,我们首先判断是否所有零件都已经处理完毕,如果是,则更新最小重量,并返回。如果没有处理完毕,则枚举所有机器,将当前零件分配给一台机器,并处理下一个零件。在处理下一个零件之前,我们需要判断当前的分配方案是否已经大于当前最小重量,如果是,则可以剪枝,退出当前分配方案。在回溯时,我们需要撤销当前零件的分配方案,以便继续枚举其他分配方案。 需要注意的是,在回溯算法中,我们使用了一个数组`a`来记录每个零件的分配机器编号。如果某个零件没有分配机器,则对应的数组元素为-1。此外,在回溯时,我们需要将当前零件的分配方案撤销,以便枚举其他分配方案。 最后,我们在主函数中输入零件的重量机器的数量,然后调用`dfs`函数进行处理,并输出最小重量
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

摆烂.MVP

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值