回溯法解决最小机器重量问题

1.问题描述：

       设某一机器由n个部件组成，每一种部件都可以从m个不同的供应商处购得。设 w_ij 是从供应商j 处购得的部件i的重量，c_ij 是相应的价格。
试设计一个回溯算法，对于给定的机器部件重量和机器部件价格，计算总价格不超过c的最小重量机器设计。

2.解题思路：

    由于题目已经给出总价格的上限，因此算法通过使用回溯来选择合适的机器使得在总价格不超过d时得到的机器重量最小。首先初始化当前价格cp=0,当前重量cw=0,此外，还要设置一个变量sum表示选择机器的总重量，初始化其为每个部件从1号供应商购买的重量。在循环选择i号机器时，判断从j号供应商购买机器后的价格是否大于总价格，如果不大于则选择，否则不选，继续选择下一供应商进行判断。在得到一个合适的供应商后，继续选择下一机器的供应商，从第一个选到最后一个供应商。当所有机器选择结束后，判断得到的总重量是否比之前的sum小，如果小就赋给sum，然后从这一步开始，回溯到上一机器，选择下一合适供应商，继续搜索可行解，直到将整个排列树搜索完毕。这样，最终得到的sum即为最优解。 
     当然，考虑到算法的时间复杂度，还可以加上一个剪枝条件，即在每次选择某一机器时，再判断选择后的当前重量是否已经大于之前的sum，如果大于就没必要继续搜索了，因为得到的肯定不是最优解。

3.算法设计：

       回溯法要求要给出约束条件，很明显：总价格不超过c，

设当前已选部件的重量和为cw，价格之和为cc，

当前最优重量用bestw表示，初始化bestw=∞；

限界条件：cw<bestw;

a.部件有n个，供应商有m个，分别用w[i][j]和c[i][j]存储从供应商j 处购得的部件i的重量和相应价格，d为总价格的上限。 
b.用递归函数backtrack(i)来实现回溯法搜索排列树（形式参数i表示递归深度）。 
  ① 若cp>d，则为不可行解，剪去相应子树，返回到i-1层继续执行。 
  ② 若cw>=sum，则不是最优解，剪去相应子树，返回到i-1层继续执行。 
  ③ 若i>n，则算法搜索到一个叶结点，用sum对最优解进行记录，返回到i-1层继续执行； 
  ④ 用for循环对部件i从m个不同的供应商购得的情况进行选择(1≤j≤m）。 
c.主函数调用一次Knapsack(1)即可完成整个回溯搜索过程，最终得到的sum即为所求最小总重量。

4.代码：

程序中最大的循环出现在递归函数backtrack(i)中，而此函数遍历排列树的时间复杂度为O(n!),故该算法的时间复杂度为O(n!)。

[cpp]  view plain  copy

1. #include<iostream>  
2. #include<stdio.h>  
3. using namespace std;  
4. int w[100][100];//w[i][j]为第i个零件在第j个供应商的重量  
5. int c[100][100];//c[i][j]为第i个零件在第j个供应商的价格  
6. int bestx[100];//bestx[i]表示一次搜索到底后的最优解，用来存放第i个零件的供应商，  
7. int x[100];//x[i]临时存放第i个零件的供应商  
8. int cw=0,cc=0,bestw=10000;  
9. int cost;//限定价格  
10. int n;//部件数  
11. int m;//供应商数  
12. void Backtrack(int t)  
13. {  
14.     int j;  
15.     if(t>n)//搜索到叶子结点，一个搜索结束，所有零件已经找完  
16.     {  
17.         bestw=cw;//当前最小重量  
18.         for(j=1;j<=n;j++)  
19.             bestx[j]=x[j];  
20.     }  
21.     else  
22.     {  
23.         for(j=1;j<=m;j++)  
24.         {  
25.             if(cc+c[t][j]<=cost && cw+w[t][j]<bestw)  
26.             {  
27.                 x[t]=j;  
28.                 cc+=c[t][j];  
29.                 cw+=w[t][j];  
30.                 Backtrack(t+1);  
31.                 cc-=c[t][j];  
32.                 cw-=w[t][j];  
33.             }  
34.         }  
35.     }  
36. }  
37.   
38. int main()  
39. {  
40.     int i,j;  
41.     cout<<"请输入部件数："<<endl;  
42.     cin>>n;  
43.     cout<<"请输入供应商数："<<endl;  
44.     cin>>m;  
45.     cout<<"请输入限定价格："<<endl;  
46.     cin>>cost;  
47.     cout<<"请输入各部件的在不同供应商的重量："<<endl;  
48.     for(i=1; i<=n; i++)  
49.         for(j=1; j<=m; j++)  
50.             cin>>w[i][j];  
51.     cout<<"请输入各部件的在不同供应商的价格："<<endl;  
52.     for(i=1; i<=n; i++)  
53.         for(j=1; j<=m; j++)  
54.             cin>>c[i][j];  
55.     Backtrack(1);  
56.     cout<<"每个部件的供应商："<<endl;  
57.     for(i=1;i<=n;i++)  
58.         cout<<bestx[i]<<' ';  
59.     cout<<endl;  
60.     cout<<bestw;  
61.     return 0;  
62. }  
63. /* 
64. 测试数据: 
65. 3 
66. 3 
67. 7 
68. 1 2 3 
69. 3 2 1 
70. 2 3 2 
71. 1 2 3 
72. 5 4 2 
73. 2 1 2 
74. */  

另一种写法：

[cpp]  view plain  copy

1. #include<iostream>  
2. #define N 1000  
3. using namespace std;  
4.   
5. int n,m,d,cp=0,cw=0,sum=0;  
6. int c[N][N],w[N][N];  
7.   
8. void backtrack(int i){  
9.      if(i>n){  
10.        if(cw<sum)  
11.          sum = cw;  
12.        return ;  
13.      }  
14.      for(int j=1;j<=m;j++){  
15.          cw+=w[i][j];  
16.          cp+=c[i][j];  
17.          if(cw<sum && cp<=d)  
18.            backtrack(i+1);  
19.          cw-=w[i][j];  
20.          cp-=c[i][j];  
21.      }  
22. }  
23.   
24. int main(){  
25.     cin>>n>>m>>d;  
26.     for(int i=1;i<=n;i++){  
27.       for(int j=1;j<=m;j++)  
28.         cin>>c[i][j];  
29.       sum+=c[i][1];  
30.     }  
31.     for(int i=1;i<=n;i++)  
32.       for(int j=1;j<=m;j++)  
33.         cin>>w[i][j];  
34.     backtrack(1);  
35.     cout<<sum<<endl;  
36.     system("pause");  
37.     return 0;  
38. }