0027算法笔记回溯法回溯法与装载问题.docx

0027算法笔记回溯法回溯法与装载问题.docx

《0027算法笔记回溯法回溯法与装载问题.docx》由会员分享，可在线阅读，更多相关《0027算法笔记回溯法回溯法与装载问题.docx（17页珍藏版）》请在冰豆网上搜索。

0027算法笔记回溯法回溯法与装载问题

1、回溯法

（1）描述:

回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。

但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法。

（2）原理:

 回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。

算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。

如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索。

   回溯法的基本做法是搜索，或是一种组织得井井有条的，能避免不必要搜索的穷举式搜索法。

这种方法适用于解一些组合数相当大的问题。

有许多问题，当需要找出它的解集或者要求回答什么解是满足某些约束条件的最佳解时，往往要使用回溯法。

    （3）问题的解空间

   问题的解向量：

回溯法希望一个问题的解能够表示成一个n元式（x1,x2,…,xn）的形式。

   显约束：

对分量xi的取值限定。

   隐约束：

为满足问题的解而对不同分量之间施加的约束。

   解空间：

对于问题的一个实例，解向量满足显式约束条件的所有多元组，构成了该实例的一个解空间。

   注意：

同一个问题可以有多种表示，有些表示方法更简单，所需表示的状态空间更小（存储量少，搜索方法简单）。

    例1：

n=3的0——1背包问题的回溯法搜索过程。

W=[16,15,15] p=[45,25,25] C=30 

   例2：

旅行售货员问题。

某售货员要到若干城市去推销商品，已知各城市之间的路程（旅费），他要选定一条从驻地出发，经过每个城市一遍，最后回到驻地的路线，使总的路程（总旅费）最小。

   （4）生成问题状态的基本方法

   扩展结点:

一个正在产生儿子的结点称为扩展结点。

   活结点:

一个自身已生成但其儿子还没有全部生成的节点称做活结点。

   死结点:

一个所有儿子已经产生的结点称做死结点。

   深度优先的问题状态生成法：

如果对一个扩展结点R，一旦产生了它的一个儿子C，就把C当做新的扩展结点。

在完成对子树C（以C为根的子树）的穷尽搜索之后，将R重新变成扩展结点，继续生成R的下一个儿子（如果存在）。

   宽度优先的问题状态生成法：

在一个扩展结点变成死结点之前，它一直是扩展结点。

   回溯法：

为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数（boundingfunction）来处死那些实际上不可能产生所需解的活结点，以减少问题的计算量。

具有限界函数的深度优先生成法称为回溯法。

   （5）回溯法的基本思想

   基本思想：

   用回溯法解题的一个显著特征是在搜索过程中动态产生问题的解空间。

在任何时刻，算法只保存从根结点到当前扩展结点的路径。

如果解空间树中从根结点到叶结点的最长路径的长度为h（n），则回溯法所需的计算空间通常为O（h（n））。

而显式地存储整个解空间则需要O（2h（n））或O（h（n）!

）内存空间。

   解题步骤：

   1）针对所给问题，定义问题的解空间；

   2）确定易于搜索的解空间结构；

   3）以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

  常用剪枝函数：

用约束函数在扩展结点处剪去不满足约束的子树；用限界函数剪去得不到最优解的子树。

   递归回溯：

    回溯法对解空间作深度优先搜索，因此，在一般情况下用递归方法实现回溯法。

[cpp] viewplain copy

1.void backtrack （int t）  

2.{  

3.    if （t>n）   

4.        output（x）; //已到叶子结点，输出结果  

5.    else  

6.    for （int i=f（n,t）;i<=g（n,t）;i++） {  

7.        x[t]=h（i）;  

8.        if （constraint（t）&&bound（t））  

9.            backtrack（t+1）;  

10.    }  

11.}  

  f（n,t），g（n,t）：

表示当前扩展结点处未搜索过的子树的起始编号和终止编号。

  h（i）：

表示在当前扩展结点处x[t]的第i个可选值。

   迭代回溯：

   采用树的非递归深度优先遍历算法，可将回溯法表示为一个非递归迭代过程。

[cpp] viewplain copy

1.void iterativeBacktrack （）  

2.{  

3.    int t=1;  

4.    while （t>0） {  

5.        if （f（n,t）<=g（n,t））   

6.            for （int i=f（n,t）;i<=g（n,t）;i++） {  

7.                x[t]=h（i）;  

8.                if （constraint（t）&&bound（t）） {  

9.                    if （solution（t）） output（x）;  

10.                    else t++;  

11.                }  

12.        }  

13.        else t--;  

14.    }  

15.}  

   子集树与排列树：

   子集树：

当所给的问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间称为子集树。

例如，那个物品的0-1背包问题所相应的解空间树就是一颗子集树。

这类子集问题通常有2^n个叶节点，其节点总个数为2^（n+1）-1。

遍历子集树的任何算法均需要O（2^n）的计算时间。

   用回溯法遍历子集树的一般算法可描述如下：

[cpp] viewplain copy

1.void backtrack （int t）  

2.{   

3.    if （t>n） output（x）;  

4.    else  

5.        for （int i=0;i<=1;i++） {  

6.            x[t]=i;  

7.            if （legal（t）） backtrack（t+1）;  

8.        }  

9.}  

  排列树：

当所给问题是确定n个元素满足某种性质的排列时，相应的解空间树称为排列树。

排列树通常有n!

个叶子节点。

因此遍历排列树需要O（n!

）的计算时间。

  用回溯法遍历排列树的一般算法可描述如下：

[cpp] viewplain copy

1.void backtrack （int t）  

2.{   

3.    if （t>n） output（x）;  

4.    else  

5.        for （int i=t;i<=n;i++） {  

6.            swap（x[t], x[i]）;  

7.            if （legal（t）） backtrack（t+1）;  

8.            swap（x[t], x[i]）;  

9.        }  

10.}   

  2、装载问题

   问题描述：

有一批共n个集装箱要装上2艘载重量分别为c1和c2的轮船，其中集装箱i的重量为wi，且

，装载问题要求确定是否有一个合理的装载方案可将这些集装箱装上这2艘轮船。

如果有，找出一种装载方案。

   例如：

当n=3,c1=c2=50,且w=[10,40,40]时，则可以将集装箱1和2装到第一艘轮船上，而将集装箱3装到第二艘轮船上；如果w=[20,40,40]，则无法将这3个集装箱都装上轮船。

  基本思路：

 容易证明，如果一个给定装载问题有解，则采用下面的策略可得到最优装载方案。

（1）首先将第一艘轮船尽可能装满；

（2）将剩余的集装箱装上第二艘轮船。

  将第一艘轮船尽可能装满等价于选取全体集装箱的一个子集，使该子集中集装箱重量之和最接近C1。

由此可知，装载问题等价于以下特殊的0-1背包问题。

   用回溯法设计解装载问题的O（2^n）计算时间算法。

在某些情况下该算法优于动态规划算法。

   算法设计：

  用回溯法解装载问题时，用子集树表示其解空间显然是最合适的。

用可行性约束函数可剪去不满足约束条件

的子树。

在子集树的第j+1层的结点z处，用cw记当前的装载重量，即cw=

，则当cw>c1时，以结点z为根的子树中所有结点都不满足约束条件，因而该子树中的解均为不可行解，故可将该子树剪去。

（该约束函数去除不可行解，得到所有可行解）。

   可以引入一个上界函数，用于剪去不含最优解的子树，从而改进算法在平均情况下的运行效率。

设z是解空间树第i层上的当前扩展结点。

cw是当前载重量；bestw是当前最优载重量；r是剩余集装箱的重量，即r=

。

定义上界函数为cw+r。

在以z为根的子树中任一叶结点所相应的载重量均不超过cw+r。

因此，当cw+r<=bestw时，可将z的右子树剪去。

   递归回溯具体代码如下：

[cpp] viewplain copy

1.#include "stdafx.h"  

2.#include   

3.using namespace std;   

4.  

5.template   

6.class Loading  

7.{  

8.    //friend Type MaxLoading（Type[],Type,int,int []）;  

9.    //private:

10.    public:

11.        void Backtrack（int i）;  

12.        int n,          //集装箱数  

13.            *x,         //当前解  

14.            *bestx;     //当前最优解  

15.            Type *w,    //集装箱重量数组  

16.            c,          //第一艘轮船的载重量  

17.            cw,         //当前载重量  

18.            bestw,      //当前最优载重量  

19.            r;          //剩余集装箱重量  

20.};  

21.  

22.template   

23.void  Loading :

:

Backtrack （int i）;  

24.  

25.template  

26.Type MaxLoading（Type w[], Type c, int n, int bestx[]）;  

27.  

28.int main（）  

29.{     

30.    int n=3,m;  

31.    int c=50,c2=50;  

32.  

33.    int w[4]={0,10,40,40};  

34.    int bestx[4];  

35.  

36.    m=MaxLoading（w, c, n, bestx）;  

37.  

38.    cout<<"轮船的载重量分别为：

"<

39.    cout<<"c

（1）="<

（2）="<

40.  

41.    cout<<"待装集装箱重量分别为：

"<

42.    cout<<"w（i）=";  

43.    for （int i=1;i<=n;i++）  

44.    {  

45.        cout<

46.    }  

47.    cout<

48.  

49.    cout<<"回溯选择结果为：

"<

50.    cout<<"m

（1）="<

51.    cout<<"x（i）=";  

52.  

53.    for （int i=1;i<=n;i++）  

54.    {  

55.        cout<

56.    }  

57.    cout<

58.  

59.    int m2=0;  

60.    for （int j=1;j<=n;j++）  

61.    {  

62.        m2=m2+w[j]*（1-bestx[j]）;  

63.    }  

64.    cout<<"m

（2）="<

65.  

66.    if（m2>c2）  

67.    {  

68.        cout<<"因为m

（2）大于c

（2）,所以原问题无解！

"<

69.    }  

70.    return 0;  

71.}  

72.  

73.template   

74.void  Loading :

:

Backtrack （int i）// 搜索第i层结点  

75.{  

76.    if （i > n）// 到达叶结点  

77.    {    

78.        if （cw>bestw）  

79.        {  

80.            for（int j=1;j<=n;j++）   

81.            {  

82.                bestx[j]=x[j];//更新最优解  

83.                bestw=cw;   

84.            }  

85.        }   

86.        return;  

87.    }  

88.  

89.    r-=w[i];   

90.    if （cw + w[i] <= c） // 搜索左子树  

91.    {   

92.        x[i] = 1;  

93.        cw += w[i];  

94.        Backtrack（i+1）;  

95.        cw-=w[i];      

96.    }  

97.  

98.    if （cw + r > bestw）  

99.    {  

100.        x[i] = 0;  // 搜索右子树  

101.        Backtrack（i + 1）;    

102.    }  

103.    r+=w[i];   

104.}  

105.  

106.template  

107.Type MaxLoading（Type w[], Type c, int n, int bestx[]）//返回最优载重量  

108.{  

109.    LoadingX;  

110.    //初始化X  

111.    X.x=new int[n+1];  

112.    X.w=w;  

113.    X.c=c;  

114.    X.n=n;  

115.    X.bestx=bestx;  

116.    X.bestw=0;  

117.    X.cw=0;  

118.    //初始化r  

119.    X.r=0;  

120.  

121.    for （int i=1;i<=n;i++）  

122.    {  

123.        X.r+=w[i];  

124.    }  

125.  

126.    X.Backtrack

（1）;  

127.    delete []X.x;  

128.    return X.bestw;  

129.}  

   迭代回溯具体代码如下：

[cpp] viewplain copy

1.#include "stdafx.h"  

2.#include   

3.using namespace std;   

4.  

5.template  

6.Type MaxLoading（Type w[ ], Type c, int n, int bestx[ ]）;  

7.  

8.int main（）  

9.{     

10.    int n=3,m;  

11.    int c=50,c2=50;  

12.    int w[4]={0,10,40,40};  

13.    int bestx[4];  

14.  

15.    m=MaxLoading（w, c, n, bestx）;  

16.  

17.    cout<<"轮船的载重量分别为：

"<

18.    cout<<"c

（1）="<

（2）="<

19.  

20.    cout<<"待装集装箱重量分别为：

"<

21.    cout<<"w（i）=";  

22.    for （int i=1;i<=n;i++）  

23.    {  

24.        cout<

25.    }  

26.    cout<

27.  

28.    cout<<"回溯选择结果为：

"<

29.    cout<<"m

（1）="<

30.    cout<<"x（i）=";  

31.  

32.    for （int i=1;i<=n;i++）  

33.    {  

34.        cout<

35.    }  

36.    cout<

37.  

38.    int m2=0;  

39.    for （int j=1;j<=n;j++）  

40.    {  

41.        m2=m2+w[j]*（1-bestx[j]）;  

42.    }  

43.    cout<<"m

（2）="<

44.  

45.    if（m2>c2）   

46.    {  

47.        cout<<"因为m

（2）大于c

（2）,所以原问题无解！

"<

48.    }  

49.    return 0;  

50.}  

51.  

52.  

53.template   

54.Type MaxLoading（Type w[],Type c,int n,int bestx[]）//迭代回溯法，返回最优载重量及其相应解，初始化根结点  

55.{  

56.    int i=1;//当前层，x[1:

i-1]为当前路径  

57.    int *x=new int[n+1];  

58.  

59.    Type bestw=0,      //当前最优载重量  

60.         cw=0,         //当前载重量  

61.         r=0;          //剩余集装箱重量  

62.  

63.    for （int j=1;j<=n;j++）  

64.    {  

65.        r+=w[j];  

66.    }  

67.  

68.    while（true）//搜索子树  

69.    {       

70.        while（i<=n &&cw+w[i]<=c）//进入左子树  

71.        {  

72.            r-=w[i];  

73.            cw+=w[i];  

74.            x[i]=1;  

75.            i++;  

76.        }  

77.          

78.        if （i>n）//到达叶结点  

79.        {        

80.            for （int j=1;j<=n;j++）  

81.            {  

82.                bestx[j]=x[j];  

83.            }  

84.            bestw=cw;  

85.        }  

86.        else//进入右子树  

87.        {            

88.            r-=w[i];  

89.            x[i]=0; i++;  

90.        }  

91.        while （cw+r<=bestw）  

92.        { //剪枝回溯  

93.            i--;     

94.            while （i>0 && !

x[i]）  

95.            {   

96.                r+=w[i];  

97.                i--;  

98.            }     

99.            //从右子树返回  

100.            if （i==0）  

101.            {  

102.                delete []x;  

103.                return bestw;  

104.            }  

105.            x[i]=0;  

106.            cw-=w[i];