HDU 5418 Victor and World 允许多次经过的TSP

题目链接：

hdu:

　　http://acm.hdu.edu.cn/showproblem.php?pid=5418

bestcoder(中文):

　　http://bestcoder.hdu.edu.cn/contests/contest_chineseproblem.php?cid=619&pid=1002

Victor and World

 Accepts: 99

 Submissions: 644

 Time Limit: 4000/2000 MS (Java/Others)

 Memory Limit: 262144/131072 K (Java/Others)

问题描述

经过多年的努力，Victor终于考到了飞行驾照。为了庆祝这件事，他决定给自己买一架飞机然后环游世界。他会驾驶一架飞机沿着规定的航线飞行。在地球上一共有nn个国家，编号从11到nn，各个国家之间通过mm条双向航线连接，第ii条航线连接第u_iu​i​​个国家与第v_iv​i​​个国家，通过这条航线需要消耗w_iw​i​​升油，且从11号国家可以直接或间接到达22到nn中任意一个国家。

Victor一开始位于11号国家，他想知道从11号国家出发，经过各个国家至少一次并最后回到11号国家消耗的总油量的最小值是多少。

输入描述

第一行包含一个整数TT，表示测试数据的组数。

每组测试数据的第一行有两个整数nn和mm，表示国家的个数和航线的条数。

接下来mm行，每行三个整数u_iu​i​​, v_iv​i​​, w_iw​i​​，描述一条航线。

1\leq T\leq 201≤T≤20。

1\leq n\leq 161≤n≤16。

1\leq m\leq 1000001≤m≤100000。

1\leq w_i\leq 1001≤w​i​​≤100。

1\leq u_i, v_i \leq n1≤u​i​​,v​i​​≤n。

输出描述

每组测试数据输出一行一个整数，即消耗的总油量的最小值。

输入样例

1
3 2
1 2 2
1 3 3

输出样例

10

题解：

　　这一道题与普通tsp的差别就在与状太转移变多了，设i,j为任意的两个点，s为压缩后的状态。dp[s][i]可以由dp[s][j]转移而来，这直接破坏普通TSP无后效性的前提。因此如果还想要用dp来解这道题，就要做一点改变创新了。

方法一：比较暴力的状态压缩

　　这里状态转移用的是刷表法

代码：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;

 const int maxn=(<<)+;
 static int INF;

 int dp[maxn][],cnt[maxn];

 int mat[][];

 int n,m;

 void get_cnt(){
     memset(cnt,,sizeof(cnt));
     for(int stat=;stat<(<<);stat++){
         //统计每一个状态的已经访问了的节点的个数
         for(int i=;i<;i++){
             if(stat&(<<i)) cnt[stat]++;
         }
     }
 }

 void init(){
     memset(dp,0x3f,sizeof(dp));
     INF=dp[][];
     memset(mat,0x3f,sizeof(mat));
 }

 int main(){
     get_cnt();
     int tc;
     scanf("%d",&tc);
     while(tc--){
         init();
         scanf("%d%d",&n,&m);
         int u,v,w;
         while(m--){
             scanf("%d%d%d",&u,&v,&w);
             u--; v--;
             if(w<mat[u][v])
                 mat[u][v]=mat[v][u]=w;
         }
         dp[][]=;
         for(int s=;s<(<<n);s++){
             //做k次后能够保证引起后效性的那些转移也能得到最优解，有点像floyd算法的思想。
             for(int k=;k<=cnt[s];k++){
                 for(int i=;i<n;i++){
                     //这里要做可行性减枝，否则时间会爆。
                     if(dp[s][i]!=INF){
                         for(int j=;j<n;j++){
                             dp[s|(<<j)][j]=min(dp[s|(<<j)][j],dp[s][i]+mat[i][j]);
                         }
                     }
                 }
             }
         }
         printf("%d\n",dp[(<<n)-][]);
     }
     return ;
 }

方法二：先floyd，再直接上普通tsp的做法

代码：

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 using namespace std;

 const int maxn = ;

 int mat[maxn][maxn];
 int dp[( << )+][maxn];

 int n, m;

 void floyd() {
     for (int k = ; k < n; k++) {
         for (int i = ; i < n; i++) {
             for (int j = ; j < n; j++) {
                 mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
             }
         }
     }
 }

 void init() {
     memset(mat, 0x3f, sizeof(mat));
     for (int i = ; i < maxn; i++) mat[i][i] = ;
     memset(dp, 0x3f, sizeof(dp));
 }

 int main() {
     int tc;
     scanf("%d", &tc);
     while (tc--) {
         init();
         scanf("%d%d", &n, &m);
         int u, v, w;
         while (m--) {
             scanf("%d%d%d", &u, &v, &w);
             u--; v--;
             if (mat[u][v] > w) mat[u][v] = mat[v][u] = w;
         }
         floyd();
         dp[][] = ;
         //这里只是做出一个哈密顿通路
         for (int s = ; s < ( << n); s++) {
             for (int i = ; i < n; i++) {
                 if (s&( << i)) {
                     for (int j = ; j < n; j++) {
                         if ((s&( << j))== ) {
                             dp[s | ( << j)][j] = min(dp[s | ( << j)][j], dp[s][i] + mat[i][j]);
                         }
                     }
                 }
             }
         }
         //补回路
         int ans = 0x3f3f3f3f;
         for (int i = ; i < n; i++) {
             ans = min(ans, dp[( << n) - ][i] + mat[i][]);
         }
         if (n == ) printf("0\n");
         else printf("%d\n", ans);
     }
     return ;
 }