tsp动态规划算法C语言,商旅问题TSP——动态规划（c++ 动态规划）

城市间的车票价钱 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<

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< 如从集合j=7={3，2，1}中取出城市2变为j={3,1}=101=5;

7^(1<

代码如下：

#include

#include

using namespace std;

const int MAX = 100000;

int main()

{

int n;//城市数量

cin >> n;

vector>dis(n, vector(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>dp(n, vector(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<

return 0;

} (2-1))=7>(k-1))>