回溯法

回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择。

解空间树

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

子集树与排列树：

子集树：当所给的问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间称为子集树。例如，那个物品的0-1背包问题所相应的解空间树就是一颗子集树。这类子集问题通常有2^n个叶节点，其节点总个数为2^(n+1)-1。遍历子集树的任何算法均需要O(2^n)的计算时间。

排列树：当所给问题是确定n个元素满足某种性质的排列时，相应的解空间树称为排列树。排列树通常有n!个叶子节点。因此遍历排列树需要O(n!)的计算时间。

生成问题状态的基本方法

Tips:生成可以理解为访问

 扩展结点:一个正在产生儿子的结点称为扩展结点。
 活结点:一个自身已生成但其儿子还没有全部生成的节点称做活结点。
 死结点:一个所有儿子已经产生的结点称做死结点。
 深度优先的问题状态生成法：如果对一个扩展结点R，一旦产生了它的一个儿子C，就把C当做新的扩展结点。在完成对子树C（以C为根的子树）的穷尽搜索之后，将R重新变成扩展结点，继续生成R的下一个儿子（如果存在）。

 宽度优先的问题状态生成法：在一个扩展结点变成死结点之前，它一直是扩展结点。
 回溯法：为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死那些实际上不可能产生所需解的活结点，以减少问题的计算量。具有限界函数的深度优先生成法称为回溯法。

基本思想：

 用回溯法解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻，算法只保存从根结点到当前扩展结点的路径。如果解空间树中从根结点到叶结点的最长路径的长度为h(n)，则回溯法所需的计算空间通常为O(h(n))。而显式地存储整个解空间则需要O(2h(n))或O(h(n)!)内存空间。

解题步骤：

 1)针对所给问题，定义问题的解空间；
 2)确定易于搜索的解空间结构；
 3)以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

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

递归回溯：

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

void backtrack (int t)  
{  
    if (t>n)   
        output(x); //已到叶子结点，输出结果  
    else  
    for (int i=f(n,t);i<=g(n,t);i++) {  
        x[t]=h(i);  
        if (constraint(t)&&bound(t))  
            backtrack(t+1);  
    }  
}

例题解析

有一批共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背包问题。

Tips: 可以引入一个上界函数，用于剪去不含最优解的子树，从而改进算法在平均情况下的运行效率。设z是解空间树第i层上的当前扩展结点。cw是当前载重量；bestw是当前最优载重量；r是剩余集装箱的重量，即r=。定义上界函数为cw+r。在以z为根的子树中任一叶结点所相应的载重量均不超过cw+r。因此，当cw+r<=bestw时，可将z的右子树剪去。 （放完z还可以接着放）

#include "stdafx.h"
#include <iostream>
using namespace std; 

template <class Type>
class Loading
{
    //friend Type MaxLoading(Type[],Type,int,int []);
    //private:
    public:
        void Backtrack(int i);
        int n,          //集装箱数
            *x,         //当前解
            *bestx;     //当前最优解
            Type *w,    //集装箱重量数组
            c,          //第一艘轮船的载重量
            cw,         //当前载重量
            bestw,      //当前最优载重量
            r;          //剩余集装箱重量
};

template <class Type>
void  Loading <Type>::Backtrack (int i);

template<class Type>
Type MaxLoading(Type w[], Type c, int n, int bestx[]);

int main()
{   
    int n=3,m;
    int c=50,c2=50;

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

    m=MaxLoading(w, c, n, bestx);

    cout<<"轮船的载重量分别为："<<endl;
    cout<<"c(1)="<<c<<",c(2)="<<c2<<endl;

    cout<<"待装集装箱重量分别为："<<endl;
    cout<<"w(i)=";
    for (int i=1;i<=n;i++)
    {
        cout<<w[i]<<" ";
    }
    cout<<endl;

    cout<<"回溯选择结果为："<<endl;
    cout<<"m(1)="<<m<<endl;
    cout<<"x(i)=";

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

    int m2=0;
    for (int j=1;j<=n;j++)
    {
        m2=m2+w[j]*(1-bestx[j]);
    }
    cout<<"m(2)="<<m2<<endl;

    if(m2>c2)
    {
        cout<<"因为m(2)大于c(2),所以原问题无解！"<<endl;
    }
    return 0;
}

template <class Type>
void  Loading <Type>::Backtrack (int i)// 搜索第i层结点
{
    if (i > n)// 到达叶结点
    {  
        if (cw>bestw)
        {
            for(int j=1;j<=n;j++) 
            {
                bestx[j]=x[j];//更新最优解
                bestw=cw; 
            }
        } 
        return;
    }

    r-=w[i];   //i作为扩展节点向下递归
    if (cw + w[i] <= c) // 搜索左子树
    { 
        x[i] = 1;
        cw += w[i];
        Backtrack(i+1);
        cw-=w[i];    
    }

    if (cw + r > bestw)  
    {
        x[i] = 0;  // 搜索右子树
        Backtrack(i + 1);  
    }
    r+=w[i]; 
}

template<class Type>
Type MaxLoading(Type w[], Type c, int n, int bestx[])//返回最优载重量
{
    Loading<Type>X;
    //初始化X
    X.x=new int[n+1];
    X.w=w;
    X.c=c;
    X.n=n;
    X.bestx=bestx;
    X.bestw=0;
    X.cw=0;
    //初始化r
    X.r=0;

    for (int i=1;i<=n;i++)
    {
        X.r+=w[i];
    }

    X.Backtrack(1);
    delete []X.x;
    return X.bestw;
}