感谢来自Raintin_coder的分享
旅行商问题是算法中比较难的一类题目，也是比较综合的题目之一，其变种的题目也非常灵活，应用场景非常广泛，前段时间在做华为笔试题目的时候，遇到了一个与旅行商问题相关的蜜蜂飞行采花粉问题：
题目大意是：一个蜜蜂从蜂窝出发，在五朵花上采蜜之后，要飞回蜂窝，题目给出蜂巢和5朵花在二维空间中的坐标，求蜜蜂走完全程的最短路程。
这是典型的旅行商问题的应用，但是当时因为对旅行商问题不是很熟悉，为了快速写完代码，直接用了全排列（DFS）去做，但是复杂度是指数级的，6个节点还好，一旦节点变多必会出现超时情况。
旅行商问题描述：该类问题的最优解要求的是除了起始节点外，其他每个节点只能经过一次，也就是说，所有节点的入度和出度都只能是1，（旅行商问题有个特点，通常是所有节点之间都可以自由连同，因为只有每个节点至少有两个度，才能画出一个不回头的路线），画出沿途路径之后就是哈密顿图，如下所示：
解决旅行商问题有很多种：
1、上述提到的permutation方法属于直接暴力法，这种方法在节点情况比较少的时候可以通过，但是，基本没啥技术含量，不容易出错，因此可以用它来做对数器。
2、DFS深度优先遍历也是解决该问题中比较好的方法，属于贪心算法，从一个点开始不断的遍历下去，最终找到一个最短的方案，在该题目中，复杂度是指数级的，但是可以有效处理某些点之间不通的问题，避免无效运算。
3、动态规划是我们常用到的方式，一般动态规划是从暴力方法中提取出来的，但是，该题目中动态规划的思路不是很好想，也正因为该方法不好想，所以针对动态规划来进行分析。但是所有的动态规划，其本质都是来源于暴力求解，在直观点说，dp和dfs密不可分，二者都是采用了分治策略，只是dp会对状态量进行保存，避免了重复计算，如何对DFS改写DP，请大家参考左神的课程，我觉得讲的很好。
首先，假设共有4各点，0为起始点，从0点出发，经过1、2、3点之后回到0点为一个完整过程，这个过程实际上是0 -> (1、2、3)->0，表示的是从0点出发经过1、2、3这个集合的所有点之后回到0点，实际上我们可以把过程分解为：(0->k)和((S)->0)两个过程，其中，k是（1、2、3）集合中的一个点，S是不包含k的集合，举个例子：假定k选择的是1号点，我们需要求出0->1之间的距离 d11，在求出1->（2、3）->0的最短距离 d12，总路程d1 = d11+d12。同理，假设k选择的是2号点，我们相应求出距离d2，假设k选择的是3号点，我们相应求出距离d3，然后选择d1，d2，d3中的最小值，min(d1, d2, d3)，得到最终结论，至于子过程1->(2、3)->0，也可以通过 上述方法求得结果，顺着该思路，可以直接写出DFS代码，但是，DFS代码因其不保存状态，使得有些状态量会反复参与运算，造成复杂度升高，而此方案中，dp方案依然是指数级。
有了以上的推论，我们知道，一个点（i）通过某一个集合（j）到达初始点（0）的过程可以表示为两个子过程的加和，选择点k，则 d[i][j] = c[i][k]+d[k][l]，c[i][k]表示点i到点k的距离，l表示j集合中除了k点其他点组成的集合。也就是说，当知道了集合 j 中每一个元素通过其剩下元素组成的集合后返回起始点的距离，用一个for循环在比较，求出所有方案中的最小值，即为最优解。
为了方便理解，可以将上述过程用一张dp表来表示：
|
| {} | {1} | {2} | {1、2} | {3} | {1、3} | {2、3} | {1、2、3} |
|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 0 |
|
|
|
|
|
|
|
|
| 1 |
|
|
|
|
|
|
|
|
| 2 |
|
|
|
|
|
|
|
|
| 3 |
|
|
|
|
|
|
|
|
j集合中表示的点为该数二进制中为为1的位置，哪个位上为1，标志哪个点在该集合内，例如，集合3的二进制为011，表示（1，2），集合7的二进制为111， 表示（1，2，3）。
dp[0][0]表示从起始点经过空集返回，长度为0。 d[0][1]表示从起始点出发，经过集合1返回起始点，过程是：0->1->0，结果是2倍的0->1的距离.
d[1][2]表示从点1出发，经过集合2返回起始点，过程是：1->2->0，结果是1->2和2->0这两段的距离和。 dp[2][1]表示从点2出发，经过集合1返回起始点，过程是：2->1->0，结果是2->1和1->0这两段的距离和，而dp[0][2]可以表示:
dp[0][2] = max(c[0][1]+dp[1][2], c[0][2]+dp[2][1])
同理，不断计算每个对应位置的数值，求得最终的结果：
dp[0][7] = max(c[0][1]+dp[1][6], c[0][2]+dp[2][5], c[0][3]+dp[3][3])
通过一个具体的例子来进行说明，
根据上述算法，对该拓扑结构中的距离进行求解，然后开始填dp表，根据递推关系应该按列填，第一列是点i到起始点的距离，因此，
for (int i=0; i<N; ++i) {
dp[i][0] = graph[i][0];
}
dp[0][0] = 0;
其中，上述代码的graph变量为邻接矩阵。
此后安列填空，因为每一列都要用到前几列的信息，所以，该编码形式下无法进行空间压缩。
后续代码：
for (int j=1; j<col; ++j) {
for (int i=0; i<N; ++i) {
if (i>0 && j&(1<<(i-1))) {
continue;
}
for (int k=1; k<N; ++k) {
if (j&(1<<(k-1)) == 0) {
continue;
}
//cik + dp[k][j^k];
if (graph[i][k] != -1 && dp[k][j^(1<<(k-1))] != -1) {
dp[i][j] = dp[i][j] == -1 ? graph[i][k]+dp[k][j^(1<<(k-1))] : min(dp[i][j], graph[i][k]+dp[k][j^(1<<(k-1))]);
}
}
}
}
上述代码的意思是，因为需要按列填空，所以，表示dp列信息的j作为第一层循环，表示行信息的i为第二层循环，首先判断i是否在j中，i不能在j集合中，这是前提，因此，需要加入判断语句。在j集合中选择一个点，但是，这里我们无法直接判断出j中包含的点数，所以，只能遍历所有点，加入判断，k点是否在j中，只有当k在j中时，才进行操作。
另外，我的代码中，所有的dp初始值和不通的情况都是用-1表示的，因此，要加入额外判断，避免出现求解问题，即，如果某些值为-1，表示该路不通，则不去参与数值更新。填空结果如下：
|
| {} | {1} | {2} | {1、2} | {3} | {1、3} | {2、3} | {1、2、3} |
|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 0 | 0 | 20 | 30 | 60 | -1 | -1 | -1 | 80 |
| 1 | 10 | -1 | 50 | -1 | -1 | -1 | 70 | -1 |
| 2 | 15 | 45 | -1 | -1 | -1 | 65 | -1 | -1 |
| 3 | -1 | 35 | 45 | 75 | -1 | -1 | -1 | -1 |
以下是整个代码的实现如下：
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
int shortestPath (vector<vector<int>>& graph, int N) {
int col = 1<<(N-1);
vector<vector<int>> dp (N, vector<int> (col, -1));
for (int i=0; i<N; ++i) {
dp[i][0] = graph[i][0];
}
dp[0][0] = 0;
for (int j=1; j<col; ++j) {
for (int i=0; i<N; ++i) {
if (i>0 && j&(1<<(i-1))) {
continue;
}
for (int k=1; k<N; ++k) {
if (j&(1<<(k-1)) == 0) {
continue;
}
//cik + dp[k][j^k];
if (graph[i][k] != -1 && dp[k][j^(1<<(k-1))] != -1) {
dp[i][j] = dp[i][j] == -1 ? graph[i][k]+dp[k][j^(1<<(k-1))] : min(dp[i][j], graph[i][k]+dp[k][j^(1<<(k-1))]);
}
}
}
}
return dp[0][col-1];
}
};
int main()
{
int N = 4, P = 5;
//cin >> N >> P;
vector<vector<int>> routes = {{0, 1, 10}, {0, 2, 15}, {1, 2, 35}, {1, 3, 25}, {2, 3, 30}};
vector<vector<int>> graph (N, vector<int> (N, -1));
for (int i=0; i<P; ++i) {
int x = 0, y = 0, z = 0;
x = routes[i][0], y = routes[i][1], z = routes[i][2];
//cin >> x >> y >> z;
graph[x][y] = z;
graph[y][x] = z;
}
Solution solve;
solve.shortestPath(graph, N);
return 0;
}
因为即使是动态规划下，旅行商问题的复杂度依然是指数级的，因此，该问题一般不会出现很大的数据集，而现实生活中，要解决该类问题，可以使用蚁群，启发式等算法来解决，通过加入孙子节点，来判断等等，这里就不展开来讲了，有兴趣的同学可以百度，都有代码，但整体复杂度都不低。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
