回溯法（3）

四、0-1背包问题

问题表述：给定n种物品和一背包。物品i的重量是wi，其价值为pi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大?

0-1背包问题是一个特殊的整数规划问题。

解空间：

可行性约束函数：

上界函数：

考虑一个右子树的时候，设

r：是当前未考虑的剩余物品的总价值(remainder)

cp：是当前的价值(current price)

bestp：是当前得到的最优价值(best price)

那么，满足：

但是，上界r太松。

一个更加紧的上界：

将剩余物品按照单位重量价值排序，然后依次装入物品，直到装不下，再将剩余物品的一部分放入背包。(r_n  <=  r)

实现

?
/* 主题：0-1背包问题
* 作者：chinazhangjie
* 邮箱：chinajiezhang@gmail.com
* 开发语言：C++
* 开发环境：Mircosoft Virsual Studio 2008
* 时间: 2010.10.25
*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
 
class goods {
public:
    int weight; // 重量
    int price;  // 价格
    goods() : weight(0),price(0) 
    {}
};
 
bool goods_greater(const goods& lhs,const goods& rhs)
{
    return (lhs.price / lhs.weight) > (rhs.price / rhs.weight);
}
 
class knapsack 
{
public:
    knapsack (int c,const vector<goods>& gl) 
        : capacity (c), curr_price(0), best_price (0), curr_weight(0){
        goods_list = gl;
        total_layers = gl.size();
        curr_path.resize (total_layers);
        best_path.resize (total_layers);
    }
    void backtrack () {
        __backtrack (0);
        cout << "path: " ;
        copy (best_path.begin(),best_path.end(),ostream_iterator<int> (cout, " "));
        cout << endl;
        cout << "best_price: " << best_price << endl;
    }
 
private:
    // 计算上界
    int __bound (int layers) {
        int cleft = capacity - curr_weight;
        int result = curr_price;
        // 将layer之后的物品进行按单位价格降序排序
        vector<goods> tmp = goods_list;
        sort (tmp.begin() + layers, tmp.end(),goods_greater);
        // 以物品单位重量价值递减序装入物品
        while (layers < total_layers && tmp[layers].weight <= cleft) {
            cleft -= tmp[layers].weight;
            result += tmp[layers].price;
            ++ layers;
        }
        // 装满背包
        if (layers < total_layers) {
            result += (tmp[layers].price / tmp[layers].weight) * cleft;
        }
        return result;
    }
 
    void __backtrack (int layers) {
        // 到达叶子结点，更新最优价值
        if (layers >= total_layers) {
            if (curr_price > best_price || best_price == 0) {
                best_price = curr_price;
                copy (curr_path.begin(), curr_path.end(), best_path.begin());
            }
            return ;
        }
        // 左剪枝（能放的下）
        if (curr_weight + goods_list[layers].weight <= capacity) {
            curr_path[layers] = 1;
            curr_weight += goods_list[layers].weight;
            curr_price += goods_list[layers].price;
            __backtrack (layers + 1);
            curr_weight -= goods_list[layers].weight;
            curr_price -= goods_list[layers].price;
        }
        // 右剪枝
        if (__bound (layers + 1) > best_price || best_price == 0 ) {
            curr_path[layers] = 0;
            __backtrack (layers + 1);
        }
        /*curr_path[layers] = 0;
        __backtrack (layers + 1);*/
    }
 
private:
    vector<goods> goods_list; // 货物信息列表
    int capacity;               // 背包承载量
    int curr_price;             // 当前价格
    int curr_weight;            　　　　// 当前重量
    int best_price;             // 当前得到的最优价值
    int total_layers;           // 总层数
    vector<int> curr_path;        // 当前路径
    vector<int> best_path;        // 最优价值下的路径
};
 
int main() 
{
    const int size = 3;
    vector<goods> gl(size);
    gl[0].weight = 10;
    gl[0].price = 1;
    gl[1].weight = 8;
    gl[1].price = 4;
    gl[2].weight = 5;
    gl[2].price = 5;
 
    knapsack ks(16, gl);
    ks.backtrack ();
    return 0;
}

五、旅行售货员问题

问题表述：在图中找到一个权最小的周游路线

解空间：排列树

剪枝策略：

当前路径的权重＋下一个路径的权重 < 当前的最小权重，则搜索该路径

实现：

/* 主题：旅行售货员问题
* 作者：chinazhangjie
* 邮箱：chinajiezhang@gmail.com
* 开发语言：C++
* 开发环境：Mircosoft Virsual Studio 2008
* 时间: 2010.10.26
*/
 
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
using namespace std;
 
class traveling 
{
public:
    static const int NOEDGE  = -1 ; 
public:
    traveling (const vector<vector<int> >& ug)
        : curr_cost (0), best_cost (-1) {
        node_count = ug.size ();
        undigraph = ug;
        curr_solution.resize (node_count);
        for (int i = 0; i < node_count; ++ i) {
            curr_solution[i] = i;
        }
        best_solution.resize (node_count);
    }
    void backtrack () {
        __backtrack (1);
        cout << best_cost << endl;
    }
 
private:
    void __backtrack (int layers) {
        if (layers >= node_count) {
            if (undigraph[curr_solution[node_count - 1]][curr_solution[0]] == NOEDGE){
                return ;
            }
            int total_cost = curr_cost +
                undigraph[curr_solution[node_count - 1]][curr_solution[0]] ;
            if (total_cost < best_cost || best_cost == -1) {
                // 更新最优费用和最优路径
                best_cost = total_cost;
                copy (curr_solution.begin(), 
                    curr_solution.end(), 
                    best_solution.begin());
            }
            return ;
        }
        for (int i = layers; i < node_count; ++ i) {
            // 剪枝
            if (undigraph[curr_solution[layers - 1]][curr_solution[i]] != NOEDGE && 
                ( curr_cost + undigraph[curr_solution[layers - 1]][curr_solution[i]]
                < best_cost || best_cost == -1 )) {
                // 搜索子树
                swap (curr_solution[layers],curr_solution[i]);
                curr_cost += 
                    undigraph[curr_solution[layers - 1]][curr_solution[layers]];
                __backtrack (layers + 1);
                curr_cost -= 
                    undigraph[curr_solution[layers - 1]][curr_solution[layers]];
                swap (curr_solution[layers],curr_solution[i]);  
 
            }
             
        }
    }
    int             node_count;     // 结点个数
    int             curr_cost;      // 当前费用
    int             best_cost;      // 当前
    vector<int>       curr_solution;  // 当前解决方案
    vector<int>       best_solution;  // 最优解决方案
    vector<vector<int> > undigraph; // 无向图(采用矩阵存储)
};
int main() 
{
    int size = 4;
    vector<vector<int> > ug(size);
    for (int i = 0;i < size; ++ i) {
        ug[i].resize (size);
    }
 
    ug[0][0] = -1;
    ug[0][1] = 30;
    ug[0][2] = 6;
    ug[0][3] = 4;
 
    ug[1][0] = 30;
    ug[1][1] = -1;
    ug[1][2] = 5;
    ug[1][3] = 10;
 
    ug[2][0] = 6;
    ug[2][1] = 5;
    ug[2][2] = -1;
    ug[2][3] = 20;
 
    ug[3][0] = 4;
    ug[3][1] = 10;
    ug[3][2] = 20;
    ug[3][3] = -1;
 
    traveling t(ug);
    t.backtrack();
 
    return 0;
}