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终于考到了飞行驾照。为了庆祝这件事，他决定给自己买一架飞机然后环游世界。他会驾驶一架飞机沿着规定的航线飞行。在地球上一共有$n$个国家，编号从$1$到$n$，各个国家之间通过$m$条双向航线连接，第$i$条航线连接第u_iu​i​​个国家与第v_iv​i​​个国家，通过这条航线需要消耗w_iw​i​​升油，且从$1$号国家可以直接或间接到达$2$到$n$中任意一个国家。

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

输入描述

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

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

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

$1\le T\le 20$。

$1\le n\le 16$。

$1\le m\le 100000$。

1leq w_ileq 1001≤w​i​​≤100。

1leq 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=(1<<16)+10;
static int INF;

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

int mat[33][33];

int n,m;

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

void init(){
    memset(dp,0x3f,sizeof(dp));
    INF=dp[0][0];
    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[1][0]=0;
        for(int s=1;s<(1<<n);s++){
            //做k次后能够保证引起后效性的那些转移也能得到最优解，有点像floyd算法的思想。 
            for(int k=0;k<=cnt[s];k++){
                for(int i=0;i<n;i++){
                    //这里要做可行性减枝，否则时间会爆。 
                    if(dp[s][i]!=INF){
                        for(int j=0;j<n;j++){
                            dp[s|(1<<j)][j]=min(dp[s|(1<<j)][j],dp[s][i]+mat[i][j]);
                        }
                    }
                }
            }
        }
        printf("%d
",dp[(1<<n)-1][0]);
    }
    return 0;
}

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

代码：

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

const int maxn = 33;

int mat[maxn][maxn];
int dp[(1 << 16)+10][maxn];

int n, m;

void floyd() {
    for (int k = 0; k < n; k++) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; 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 = 0; i < maxn; i++) mat[i][i] = 0;
    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[1][0] = 0;
        //这里只是做出一个哈密顿通路
        for (int s = 1; s < (1 << n); s++) {
            for (int i = 0; i < n; i++) {
                if (s&(1 << i)) {
                    for (int j = 0; j < n; j++) {
                        if ((s&(1 << j))== 0) {
                            dp[s | (1 << j)][j] = min(dp[s | (1 << j)][j], dp[s][i] + mat[i][j]);
                        }
                    }
                }
            }
        }
        //补回路
        int ans = 0x3f3f3f3f;
        for (int i = 1; i < n; i++) {
            ans = min(ans, dp[(1 << n) - 1][i] + mat[i][0]);
        }
        if (n == 1) printf("0
");
        else printf("%d
", ans);
    }
    return 0;
}