状压DP dd爱探险（最短Hamilton路径升级版本）

dd爱探险

链接：https://ac.nowcoder.com/acm/contest/11211/B
来源：牛客网

时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld
题目描述
星际中有nn个空间站，任意两个空间站间可以相互跳跃，由空间站x跳跃到空间站y所需要的代价为 P[x][y],注意不保证 p[x][y]= p[y][x]，dddd可以任意选择出发的空间站，并通过恰好n−1次跳跃把所有空间站跳完，并且dddd必须选择22次跳跃，其中一次跳跃中进行重力加速，另一次跳跃中进行反重力加速，重力加速会导致当前跳跃代价变为0，反重力加速会导致当前跳跃代价翻倍(乘2)，问跳完所有空间站所需要最小代价
输入描述:
第一行一个数n(3≤n≤16)
接下来n行每行n个数，第x行第y个数表示p[x][y] (0≤p[x][y]≤100000)
输出描述:
一个数,表示最小代价
示例1
输入
复制
3
0 2 1
2 0 1
3 1 0
输出
复制
2
说明
1->2重力加速
2->3反重力加速
代价0+1*2=2

题解

状压DP
最短Hamilton路径的扩展
不同点：最短Hamilton路径需要从0->n-1,固定了终点和起点。
这题没有，所有做的时候需要注意初始化和最后的答案获取。

状态表示：
f[i][j][k]所有从0走到j，走过所有点的二进制表示为i,状态为k的所有路径的最小值
状态计算
依据倒数第二个走到哪一个点k来划分
0->k->j
f[i][j] = min(f[i][j],f[ i - {j} ][k]+a[k][j])

• k=0表示没经过加速
• k=1表示经过一次重力加速，
• k=2表示经过一次反重力加速
• k=3表示两次加速都已经结束
  重新加一下状态转移，如代码所示

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 16;
int f[1<<N][N][4],a[N][N];

int main(){
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            scanf("%d", &a[i][j]);
        }
    }

    memset(f, 0x3f, sizeof(f));
    for(int i = 0; i < n; i++){
        f[1<<i][i][0] = 0;
    }
    

    for(int i = 0; i < (1 << n); i++){
        for(int j = 0; j < n; j++){
            if(i >> j & 1){
                for(int k = 0; k < n; k++){
                    if(i >> k & 1){// 正确理解应为(i - (1 << j)) >> k & 1

                        f[i][j][0] = min(f[i][j][0], f[i - (1 << j)][k][0] + a[k][j]);
                        f[i][j][1] = min(f[i][j][1], f[i - (1 << j)][k][0]);
                        f[i][j][1] = min(f[i][j][1], f[i - (1 << j)][k][1] + a[k][j]);
                        f[i][j][2] = min(f[i][j][2], f[i - (1 << j)][k][0] + 2 * a[k][j]);
                        f[i][j][2] = min(f[i][j][2], f[i - (1 << j)][k][2] + a[k][j]);

                        f[i][j][3] = min(f[i][j][3], f[i - (1 << j)][k][1] + 2 * a[k][j]);
                        f[i][j][3] = min(f[i][j][3], f[i - (1 << j)][k][2]);
                        f[i][j][3] = min(f[i][j][3], f[i - (1 << j)][k][3] + a[k][j]);
                    }
                }
            }
        }
    }
    int res = 1e9;
    for(int i = 0; i < n; i++){
        //cout<<f[(1 << n) - 1][i][3]<<endl;
        res = min(res, f[(1 << n) - 1][i][3]);
    }
    printf("%d\n", res);
    return 0;
}