最小重量机器设计问题

★ 问题描述：设某一机器由n个部件组成，每一种部件都可以从m个不同的供应商处购得。设wij 是从供应商j处购得的部件i的重量，cij 是相应的价格。
试设计一个算法，给出总价格不超过c的最小重量机器设计。
★ 算法设计：对于给定的机器部件重量和机器部件价格，计算总价格不超过d的最小重量机器设计。
★ 数据输入：由文件input．txt给出输入数据。第一行有3个正整数n，m和d。接下来的2n行，每行n个数。 前n行是c，后n行是w。
★ 结果输出：将计算的最小重量及每个部件的供应商输出到文件output．txt。 输入文件示例1 输出文件示例1
input．txt output．txt
3 3 4 4
1 2 3 1 3 1
3 2 1
2 2 2
1 2 3
3 2 1
2 2 2

输入文件示例2
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
输出文件示例2
57
13 6 7 3 18 14 10 16
算法分析：
(1)部件有n个，供应商有m个，分别用w_[i][j]和c_[i][j]存储从供应商j 处购得的部件i的重量和相应价格，d为总价格的上限。
(2)用递归函数Backtracking(i)来实现回溯法搜索排列树（i表示递归深度）。
① 若sumc>d，则为不可行解，剪去相应子树，返回到i-1层继续执行。
② 若sumw>=minw，则不是最优解，剪去相应子树，返回到i-1层继续执行。
③ 若i>n，则算法搜索到一个叶结点，用minw和bestpath对最优解进行记录，返回到i-1层继续执行；
④ 用for循环对部件i从m个不同的供应商购得的情况进行选择(1≤j≤m）。
c.主函数调用一次Backtracking即可完成整个回溯搜索过程，最终得到的minw和bestpath即为所求最小总重量和选择方案。
时间复杂度：
题中的n个零件中每一个元素均有m种选择，即组合树。显然是n层m叉树，共有个节点。
故时间复杂度为m^n。

#include <iostream>
#include <fstream>
using namespace std;
class Machine
{
public:
	int n_, m_, d_;// n_零件个数，m_供应商个数，d_最大总价格
	int** c_; // c_[i][j]第i个零件第j个供应商得价格
	int** w_; //w_[i][j]第i个零件第j个供应商的重量
	int sumw = 0;//初始化当前已选择的零件的重量
	int sumc = 0;//当前已选择的零件的价格
	int* path;//记录第i个零件选择的供应商
	int minw = INT_MAX; //初始化最小重量
	int *bestpath;//取得最小重量时各供应商得选择

	Machine() // 把初始数据从文件中读出并初始化类
	{
		ifstream infile("input.txt");
		if (!infile)
		{
			cout << "open input.txt error!!\n";
			return;
		}
		infile >> n_ >> m_ >> d_;
		c_ = new int* [n_];
		w_ = new int* [n_];
		path = new int[n_];
		bestpath = new int[n_];
		for (int i = 0; i < n_; i++)
		{
			c_[i] = new int[m_];
			w_[i] = new int[m_];
		}
		for (int i = 0; i < n_; i++)
		{
			for (int j = 0; j < m_; j++)
			{
				infile >> c_[i][j];
			}
		}
		for (int i = 0; i < n_; i++)
		{
			for (int j = 0; j < m_; j++)
			{
				infile >> w_[i][j];
			}
		}
		infile.close();
	}

	~Machine() //析构函数，释放内存
	{
		for (int i = 0; i < n_; i++)
		{
			delete[] c_[i];
			delete[] w_[i];
		}
		delete c_;
		delete w_;
	}
	void Backtracking(int i) //主回溯函数
	{
		if (i >= n_) //递归终止条件
		{
			//重量小于最小重量，更新
			if (sumw < minw)
			{
				for (int i = 0; i < n_; i++)
				{
					bestpath[i] = path[i];
				}
				minw = sumw;
			}
			return;
		}
		else
		{
			for (int j = 0; j < m_; j++) //遍历m个供应商
			{
				sumw += w_[i][j];
				sumc += c_[i][j];
				path[i] = j;
				if (sumw < minw && sumc <= d_)//当前总价格小于最大价格，当前总重量小于最小总重量
				{
					Backtracking(i + 1);
				}
				//回溯
				sumw -= w_[i][j];
				sumc -= c_[i][j];
			}
		}
	}
	void WriteFile()//把结果写入文件
	{
		ofstream out("output.txt");
		out << minw << endl;
		for (int i = 0; i < n_; i++)
		{
			out << bestpath[i] + 1 << " ";
		}
		out.close();
	}
};

int main()
{
	Machine x;
	x.Backtracking(0);
	x.WriteFile();
	return 0;
}