商旅问题TSP——动态规划（c++ 动态规划）

1.定义

  TSP问题（旅行商问题）是指旅行家要旅行n个城市，要求各个城市经历且仅经历一次然后回到出发城市，并要求所走的路程最短。

本文以2019字节跳动春招笔试第5题，毕业旅行问题为例：

小明目前在做一份毕业旅行的规划。打算从北京出发，分别去若干个城市，然后再回到北京，每个城市之间均乘坐高铁，且每个城市只去一次。由于经费有限，希望能够通过合理的路线安排尽可能的省一些路上的花销。给定一组城市和每对城市之间的火车票的价钱，找到每个城市只访问一次并返回起点的最小车费花销。

输入描述:
城市个数n（1

城市间的车票价钱 n行n列的矩阵 m[n][n]

输出描述:
最小车费花销 s

输入例子1:
4
0 2 6 5
2 0 4 4
6 4 0 2
5 4 2 0

输出例子1:
13

例子说明1:
共 4 个城市，城市 1 和城市 1 的车费为0，城市 1 和城市 2 之间的车费为 2，城市 1 和城市 3 之间的车费为 6，城市 1 和城市 4 之间的车费为 5，依次类推。假设任意两个城市之间均有单程票可购买，且票价在1000元以内，无需考虑极端情况。

2 动态规划思想

1 出发城市：0 ；经过{1，2，3}各城市有且仅有一次，再回到出发城市0
2 dp[i]{v}:表示从城市i出发，经过集合v，回到出发点0 的最段路径
3 最后结果dp[0]{1,2,3};

dp[0]{1,2,3}=min(dis[0][1]+dp[1]{2,3}，dis[0][2]+dp[2]{1,3}，dis[0][3]+dp[3]{1,2})

dp[i]{v}=min(dis[i][k]+dp[k]{v-k});(i不属于v，k属于v)
初始条件：
dp[i]{}=dis[i][0];//从i出发，不经过任何城市，回到城市0

难点：

1 怎么表示集合V？
除出发城市0 外剩下的城市为{1，2，3}，则剩下城市所包含的所有子集为
{}，{1}，{2}，{3}，{1，2}，{1，3}，{2，3}，{1，2，3}正好2^（n-1）个

设dp[i][j]中j为除出发点之外剩下的城市集合，则j的二进制中第i为正好对应第i个城市是否在j中。如：dp[0][7]=dp[0]{3,2,1} dp[0][5]=dp[0]{3,1}。
则dp表的列数为2^（n-1）列：（可写为1<<(n-1)）

2 怎么查看集合j中某一位的状态？（判断城市k是否在集合中）
采用(j>>(k-1))&1==1判断，等于1则在，等于0则不在
如：判断城市1，2是否在集合j=5={3，1}中；
(j>>(1-1))&1=5&1=101&001=1:则城市1在集合j=5中
(j>>(2-1))&1=2&1=10&01=0:则城市2不在集合j=5中

3 怎么将集合j中某个城市置0？（即从集合j中取出某个城市k）
j^(1<<(k-1)) (和0异或不变，和1异或取反)
如从集合j=7={3，2，1}中取出城市2变为j={3,1}=101=5;
7^(1<<(2-1))=7 ^ 2=111 ^ 010=101=5;

代码如下：

#include
#include
using namespace std;
const int MAX = 100000;
int main()
{
     
	int n;//城市数量
	cin >> n;
	vector<vector<int>>dis(n, vector<int>(n));//城市距离矩阵
	for (int i = 0; i < dis.size(); i++)
	{
     
		for (int j = 0; j < dis[i].size(); j++)
		{
     
			cin >> dis[i][j];
		}
	}

	//dp[i][j]:表示从点i出发，经过集合j中的城市有且仅有1次，再回到 “出发点0” 的最短路径
	//j的取值范围为0—(2^(n-1)-1)======0—((1<

	//j:除城市i的剩下的城市集合，如城市为{0，1，2，3} ,除出发点城市0之外的城市为{3，2，1}
	 //dp[0][7]=dp[0]{3,2,1}:j的二进制 111 表示城市3，2，1都在j中

	vector<vector<int>>dp(n, vector<int>(1 << (n - 1)));//n行 2^(n-1)列

//初始化dp表的第一列：dp[k]{}
	for (int i = 0; i < n; i++)
	{
     
		dp[i][0] = dis[i][0];	
	}
//填dp表的剩余列：1—（2^(n-1)-1）列
	for (int j = 1; j < (1 << (n - 1));j++)
	{
     
		for (int i = 0; i < n; i++)
		{
     
		//将其初始化为最大值
			dp[i][j] = MAX;
			//如果城市i在集合j中，跳过
			if (((j >> (i - 1)) & 1) == 1)
				continue;
				//城市i不在j中，则dp[i]{v}=min(dis[i][k]+dp[k]{v-k});(i不属于v，k属于v)
			if (((j >> (i - 1)) & 1) == 0)
			{
     
			
				for (int k = 1; k < n; k++)
				{
     
				//除i以外所有在j中的城市城市
					if ((j >> (k - 1)) & 1 == 1)
					{
     
					//取出城市k
						if (dp[i][j]>dis[i][k] + dp[k][j ^ (1 << (k - 1))])
						{
     
						//取值小的
							dp[i][j] = dis[i][k] + dp[k][j ^ (1 << (k - 1))];
						}
					}
				}
			}
		}
	}
//输出结果：dp[0][7]=dp[0]{1,2,3}
	cout << dp[0][(1<<(n-1))-1] << endl;


	system("pause");
	return 0;
}