分支定界法求解旅行商问题

最新推荐文章于 2024-10-10 15:36:50 发布
最新推荐文章于 2024-10-10 15:36:50 发布
阅读量1.7k 收藏 10
点赞数 1
文章标签： 蓝桥杯 算法 tsp c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44214242/article/details/122216487
版权
本文详细介绍了旅行商问题(TSP)的一个经典算法实现，通过随机数据生成初始概率密度函数，并利用接受-拒绝方法进行处理。代码中采用任务树结构，通过选取路径中最小元素进行规约操作，同时实现左子树和右子树的构建，以加速收敛过程。实验结果显示，算法在不同维度下表现出良好的执行效率，平均执行时间分别为6.4毫秒（维数23）和38.8毫秒（维数33）。最后，文章展示了找到的最优路径和最佳旅行距离。
摘要由CSDN通过智能技术生成

0、问题梗概

旅行商问题(TravelingSalesmanProblem，TSP)是一个经典的组合优化问题。经典的TSP可以描述为：一个商品推销员要去若干个城市推销商品，该推销员从一个城市出发，需要经过所有城市后，回到出发地。应如何选择行进路线，以使总的行程最短。

1、随机数据的初始概率密度函数

[公式]

[公式] [公式]


2、程序运行数据

运行次数时间（维数23）时间（维数33）
13.06541 ms26.9593 ms
23.65156 ms48.6972 ms
32.66832 ms43.5297 ms
46.78412 ms44.7827 ms
59.77699 ms24.6574 ms
64.44002 ms24.3777 ms
79.36337 ms20.4059 ms
87.22274 ms45.9999 ms
98.77502 ms41.7881 ms
108.07504 ms66.3793 ms

维度 23 的平均执行时间为 6.4 毫秒，维度 33 的平均执行时间为 38.8 毫秒。


3、代码分析

I）使用数据类型

using mat_d = vector<vector<double>>;
using path_t = vector<pair<size_t, size_t>>;

II) 随机数据的初始概率密度函数

double F(double x)
{
    return (5 / 6.0) * (1 + pow(x, 4));
}
// use Acceptance-Rejection Method
// max from 0 to 1 in function F is 5/3
double GetRnd()
{
    double u1, u2;
    while (true)
    {
        u1 = rand() % MAX_DIST;
        u2 = rand() % MAX_DIST;
        if (u2 <= (3 / 5.0) * F(u1))
            return u1;
    }
}

III) 任务路径树

// Task tree node represents each reduction matrix
class TaskTree
{
private:
    double bound;
    int index_row, index_col;
​
public:
    mat_d mat;
    path_t path;
    TaskTree(const mat_d &m, const path_t &p = {}, const double b = 0);
    void PrintMat();
    void ReduceMinElem();
    void FindMinPath();
    bool PathCompleted() { return path.size() == mat.size(); }
    double GetBound() { return bound; }
    int GetRowIndex() { return index_row; }
    int GetColIndex() { return index_col; }
};

IV) 选取路径中最小元素后进行规约操作

// Minimum statute
void TaskTree::ReduceMinElem()
{
    for (size_t i = 0; i < mat.size(); i++)
    {
        double minelem_row = INF;
        for (size_t j = 0; j < mat.size(); j++)
        {
            if (minelem_row > mat[i][j])
            {
                minelem_row = mat[i][j];
            }
        }
        for (size_t j = 0; j < mat.size(); j++)
        {
            if (mat[i][j] != INF)
            {
                mat[i][j] -= minelem_row;
            }
        }
        if (minelem_row != INF)
            bound += minelem_row;
    }
    for (size_t i = 0; i < mat.size(); i++)
    {
        double minelem_col = INF;
        for (size_t j = 0; j < mat.size(); j++)
        {
            if (minelem_col > mat[j][i])
            {
                minelem_col = mat[j][i];
            }
        }
        for (size_t j = 0; j < mat.size(); j++)
        {
            if (mat[j][i] != INF)
            {
                mat[j][i] -= minelem_col;
            }
        }
        if (minelem_col != INF)
            bound += minelem_col;
    }
    FindMinPath();
}

V) 寻找最小元素过程

// Find the shortest path possible
void TaskTree::FindMinPath()
{
    index_row = -1;
    index_col = -1;
    double max_sum = -1;
    for (size_t i = 0; i < mat.size(); i++)
    {
        for (size_t j = 0; j < mat.size(); j++)
        {
            if (mat[i][j] == 0)
            {
                double min_row = INF, min_col = INF;
                for (size_t k = 0; k < mat.size(); k++)
                {
                    if (k != j && mat[i][k] < min_row)
                        min_row = mat[i][k];
                    if (k != i && mat[k][j] < min_col)
                        min_col = mat[k][j];
                }
                double max_sum_tmp = min_row + min_col;
                if (max_sum_tmp > max_sum)
                {
                    index_row = i;
                    index_col = j;
                    max_sum = max_sum_tmp;
                }
            }
        }
    }
    path.push_back(make_pair(index_row, index_col));
}

VI) 左子树情况为选取最小元素加入路径，右子树情况为不选取该元素

// Subtree containing the selected path
shared_ptr<TaskTree> SetLeft(const mat_d &m, const path_t &path, const double bound, const int index_row, const int index_col)
{
    mat_d mat = m;
    map<size_t, size_t> pathTest;
    for (size_t i = 0; i < path.size() - 1; i++)
    {
        pathTest[path[i].first] = path[i].second;
    }
    size_t pos = index_col;
    while (pathTest.find(pos) != pathTest.end())
    {
        pos = pathTest[pos];
        if (pos == index_row)
        {
            return nullptr;
        }
    }
    for (size_t i = 0; i < mat.size(); i++)
    {
        mat[index_row][i] = INF;
        mat[i][index_col] = INF;
    }
    mat[index_col][index_row] = INF;
​
    return make_shared<TaskTree>(mat, path, bound);
}
// Does not contain the subtree of the selected path
shared_ptr<TaskTree> SetRight(const mat_d &m, const path_t &p, const double bound, const int index_row, const int index_col)
{
    mat_d mat = m;
    mat[index_row][index_col] = INF;
​
    path_t path = p;
    path.pop_back();
    return make_shared<TaskTree>(mat, path, bound);
}

VII) 对旅行商问题解决进行二次封装

// Problem-solving tree
class Task
{
private:
    map<size_t, size_t> bestpath;
    list<shared_ptr<TaskTree>> tour;
    mat_d origin_mat;
    double best;
    shared_ptr<TaskTree> root;
​
public:
    Task(const size_t size, double (*pf)() = GetRnd);
    Task(const char *filename, const size_t size);
    void RunTask();
    void PrintPath();
};

VIII) 解决问题过程，核心思路优先考虑左子树以加快收敛过程

void Task::RunTask()
{
    tour.push_front(root);
    // root->PrintMat();
    while (tour.size() != 0)
    {
        shared_ptr<TaskTree> head = tour.front();
        tour.pop_front();
        if (head->GetBound() > best)
        {
            continue;
        }
        if (head->PathCompleted())
        {
            best = head->GetBound();
            bestpath.clear();
            for (size_t i = 0; i < origin_mat.size(); i++)
            {
                bestpath[head->path[i].first] = head->path[i].second;
            }
            continue;
        }
        if (head->GetRowIndex() == -1 && head->GetColIndex() == -1)
        {
            continue;
        }
        shared_ptr<TaskTree> left = SetLeft(head->mat, head->path, head->GetBound(), head->GetRowIndex(), head->GetColIndex());
        shared_ptr<TaskTree> right = SetRight(head->mat, head->path, head->GetBound(), head->GetRowIndex(), head->GetColIndex());
        if (left != nullptr)
        {
            if (left->path.size() < origin_mat.size())
            {
                if (left->GetBound() < right->GetBound())
                {
                    tour.push_front(right);
                    tour.push_front(left);
                }
                else
                {
                    tour.push_front(left);
                    tour.push_front(right);
                }
#if 0
                cout << "bound: " << tour.front()->GetBound() << endl;
                head->PrintMat();
#endif
            }
            else
            {
                tour.push_front(left);
            }
        }
        else
        {
            tour.push_front(right);
        }
    }
    PrintPath();
}

IX) 打印总体路径

void Task::PrintPath()
{
    cout << "Best path: 1 => ";
    size_t begin = 0;
    while (bestpath[begin] != 0)
    {
        cout << bestpath[begin] + 1 << " => ";
        begin = bestpath[begin];
    }
    cout << "1" << endl;
    cout << "best tour: " << best << endl;
}

X) 主函数

int main()
{
    const auto start_time = high_resolution_clock::now();
    srand(time(NULL));
    const size_t nDim1 = 6, nDim2 = 33;
#if 0
    Task t1("input.txt", nDim1);
    t1.RunTask();
#endif
#if 1
    Task t2(nDim2);
    t2.RunTask();
#endif
    const auto end_time = high_resolution_clock::now();
    PrintTime(start_time, end_time);
}

4、代码总评

Best path: 1 => 29 => 12 => 32 => 23 => 11 => 15 => 24 => 14 => 5 => 8 => 17 => 25 => 26 => 33 => 20 => 18 => 9 => 13 => 16 => 31 => 30 => 3 => 21 => 2 => 19 => 10 => 28 => 27 => 22 => 4 => 7 => 6 => 1
best tour: 239
Time: 19.0621 ms

智能指针设计在一定程度上简化了内存管理，避免了内存泄漏的问题。 一个显着的优点是尽可能多地使用指针，而不是重新创建对象，这样整个程序占用的内存很少。 从算法设计的角度来看，优先考虑左子树（即路径），这使得代码更加高效。

完整代码: https://github.com/KCNyu/Program_MSU-BIT/blob/master/C%2B%2B_LECTURE/TSP/TSP.cpp

KCN不爱打代码
关注
分支定界法——旅行商(TSP)问题
Mind_V的博客
07-01 3万+
问题描述给定一个n顶点网络（有向或无向），找出一个包含n个顶点且具有最小耗费的换路。任何一个包含网络所有顶点的换路称为一个旅行。旅行商问题（Traveling Salesman Problem，TSP）是要寻找一条耗费最少的旅行。 图1 四顶点网络如图1是一个四顶点无向网络。这个网络的一些旅行：1,2,4,
分支限界法求旅行商问题
09-17
网上很多分支限界法求旅行商问题很复杂而且正确的没几个，这是我下决心花两天时间完成的，很辛苦的
分支限界——旅行商问题分析
m0_51120903的博客
01-04 247
问题描述 某售货员要到若干城市去推销产品，已知各城市之间的路程（或旅费）。他要选定一个城市出发，经过每个城市一遍，最后回到出发的城市，使总的路程（或旅费）最小。 分支限界基本思想 分支限界法常以广度优先或以最小耗费优先的方式搜索问题的解空间树。 广度优先：搜索树的节点过程是从左到右的顺序的 深度优先：搜索树的节点过程是从上到下的顺序的 解空间树：表示问题解空间的一颗有序树，在下面会详细说到。树分为子集树和排列树。 子集树：当所给问题是从n个元素的集合S中找出S满足某种性质的子集时，相应的解
分支界限法旅行商问题
05-08
在当前目录建议一个文本文件用于建立个城市之间距离矩阵
用分支限界法解决旅行商问题
10-02
这是一个np完全问题，时间复杂度会随着n的增大而爆炸增长。目前，还没有完全解决
分支限界TSP（旅行商问题）
qq_43762247的博客
12-06 6846
TSP 问题（traveling salesman problem） 是指旅行家要旅行 n 个城市， 要求各个城市经历且仅经历一次然后回到出发城市， 并要求所走的路程最短。首先确定目标函数的界[down, up]， 可以采用贪心法确定 TSP 问题的一个上界。 如何求得 TSP 问题的一个合理的下界呢？ 对于无向图的代价矩阵， 把矩阵中每一行最小的元素相加， 可以得到一个简单的下界。 但是还有一个信息量更大的下界： 考虑一个 TSP 问题的完整解， 在每条路径上， 每个城市都有两条邻接边， 一条是进入这个城
用分支定界算法求解旅行商问题 (2007年)
05-06
在 0-1整数规划的基础上建立了数学模型,利用 MATLAB 6. 5优化工具箱中的 linprog函数进行求解,再经过分支定界算法计算,求出了只含有 0和 1的解。实验结果表明,该算法可以求解小规模旅行商问题。
分支定界法-旅行商TSP问题
12-03
分支定界法是一种用于求解优化问题的有效方法，尤其在处理整数规划和组合优化问题时，如旅行商问题（Traveling Salesman Problem, TSP）。旅行商问题是一个经典的图论问题，目标是找到访问每个城市一次并返回起始...
tsp.rar_tsp_tsp问题 分支_visual c_分支定界TSP_旅行商问题
09-19
《旅行商问题与分支定界法在Visual C++中的实现》 旅行商问题（Traveling Salesman Problem，简称TSP）是运筹学领域中一个经典的组合优化问题，它的核心在于寻找最短的可能路径，使得一个旅行商可以访问每个城市一...
分支定界求TSP问题_分支定界法_分支界定法求tsp问题_分支定界_源码
10-02
【分支定界法】是优化问题中的一种高效算法，尤其适用于解决整数规划问题，如旅行商问题（TSP）。旅行商问题是一个经典的组合优化问题，目标是在访问一系列城市并返回起点时找到最短的路径，每个城市只能访问一次。...
旅行商问题的分支限界法
06-10
Delphi程序。算法中的分支限界法解旅行商问题，只能尽快解出一个最优解。
用分支限界法求解旅行商问题
12-02
旅行商问题，即TSP问题（Travelling Salesman Problem）是指对给定一组n个城市和它们两两之间的直达距离，寻找一条闭合的旅程，使得每个城市刚好经过一次而且总的旅行距离最短。
动态规划法，回溯法，分支限界法求解TSP旅行商问题
11-17
本报告仅供参考，不足之处请指正，版权由博主所有，未经同意禁止应用于非法用途，请下载者自觉。
分支限界法求解旅行商问题
hgqqtql的专栏
03-06 1万+
问题来来自2016华为软件精英挑战赛。  问题定义 给定一个带权重的有向图G=(V,E)，V为顶点集，E为有向边集，每一条有向边均有一个权重。对于给定的顶点s、t，以及V的子集V'，寻找从s到t的不成环有向路径P，使得P经过V'中所有的顶点(对经过V'中节点的顺序不做要求)。 若不存在这样的有向路径P，则输出无解，程序运行时间越短，则视为结果越优；若存在这样的有向路径P，则输出所得到的路径，
分支界限法 旅行商问题
热门推荐
mymy_blog的博客
01-19 1万+
分支界限法解决旅行商问题。给定一系列城市和每对城市之间的距离，求解访问每一座城市一次并回到起始城市的最短回路。旅行商问题使用分支界限法求解。将问题抽象成图的问题。城市作为图的一个点，城市与城市之间的通路和距离作为图的连通线段和权重
分支限界法解决旅行商问题
qq_51774978的博客
06-21 2869
分支限界法是利用 广度优先搜索 的策略或者以 最小耗费(最大效益)优先 的方式搜索问题的解空间树，对于解空间树中的活节点 只有一次 机会成为拓展节点，活节点一旦成为扩展节点，那么将 一次性 产生其所有儿子节点。 对于优先队列式的分支限界法，这些儿子节点中，不可行解或者一定不能成为最优解的儿子节点会被舍弃，其余儿子节点将会 按照优先级依次存入一个活节点表(队列) ，此后会挑出活节点表 优先级最高 的节点作为下次扩展节点，重复此过程，直至找到问题的最优解。 我们需要利用上界和下界来对...
【分支限界法】旅行商问题(TSP)系列2
vxiao_shen_longv的博客
08-21 9046
题目 我们希望在最短的时间内看遍所有的景点，而且同一个景点只能经过一次，如何计划能在最短的时间内看完全部景点回家呢？ 问题分析 这个问题可以把景点看作顶点，把景点间的路径看作边，这样景点地图就可以抽象为一个无向带权图。本题就是求经过所有顶点最后回到起点的最短路径。 算法 分支限界法 分支限界法就是先将根结点放入活结点表中，然后循环取出表头结点，如果满足约束条件和限界条件就可以将当前结点的子结点（或...
分支限界法（优先队列）求旅行商问题
qq_55225576的博客
07-01 7018
1、问题描述： 旅行商问题（Traveling Salesman Problem，TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该问题是在寻求单一旅行者由起点出发，通过所有给定的需求点之后，最后再回到原点的最小路径成本。最早的旅行商问题的数学规划是由Dantzig等人提出。 要求：随机生成顶点数为n的图，利用优先队列式分支限界法完成旅行商问题求解。 2、分支限界法： 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。在分支限界法中，每一个活
备战蓝桥杯1
最新发布
weixin_72770922的博客
10-10 2169
【代码】备战蓝桥杯1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值