题目描述

参与考古挖掘的小明得到了一份藏宝图，藏宝图上标出了 n 个深埋在地下的宝藏屋，也给出了这 n 个宝藏屋之间可供开发的 m 条道路和它们的长度。
小明决心亲自前往挖掘所有宝藏屋中的宝藏。但是，每个宝藏屋距离地面都很远，也就是说，从地面打通一条到某个宝藏屋的道路是很困难的，而开发宝藏屋之间的道路则相对容易很多。
小明的决心感动了考古挖掘的赞助商， 赞助商决定免费赞助他打通一条从地面到某个宝藏屋的通道，通往哪个宝藏屋则由小明来决定。
在此基础上， 小明还需要考虑如何开凿宝藏屋之间的道路。已经开凿出的道路可以任意通行不消耗代价。每开凿出一条新道路，小明就会与考古队一起挖掘出由该条道路所能到达的宝藏屋的宝藏。另外，小明不想开发无用道路，即两个已经被挖掘过的宝藏屋之间的道路无需再开发。
新开发一条道路的代价是：
这条道路的长度 x 从赞助商帮你打通的宝藏屋到这条道路起点的宝藏屋所经过的宝藏屋的数量（包括赞助商帮你打通的宝藏屋和这条道路起点的宝藏屋）。
请你编写程序为小明选定由赞助商打通的宝藏屋和之后开凿的道路，使得工程总代价最小，并输出这个最小值。

输入描述:

第一行两个用空格分离的正整数 n 和 m，代表宝藏屋的个数和道路数。
接下来 m 行，每行三个用空格分离的正整数，分别是由一条道路连接的两个宝藏屋的编号（编号为 1~n），和这条道路的长度 v。

输出描述:

输出共一行，一个正整数，表示最小的总代价。

示例1

输入
4 5
1 2 1
1 3 3
1 4 1
2 3 4
3 4 1
输出
4
说明

示例2

输入
4 5
1 2 1
1 3 3
1 4 1
2 3 4
3 4 2
输出
5
说明

备注

对于 20% 的数据：保证输入是一棵树， 1≤ n≤8， v≤ 5000 且所有的 v 都相等。
对于 40% 的数据：1≤ n≤ 8， 0≤ m≤ 1000， v≤ 5000 且所有的 v 都相等。
对于 70% 的数据：1≤ n≤ 8， 0≤ m≤ 1000， v≤ 5000。
对于 100% 的数据：1≤ n≤ 12， 0≤ m≤ 1000， v≤ 500000。

解答

首先看数据范围，，如此之小大家的第一反应应该都是状压吧。再根据题意，我们不难对这个又臭又长混淆视听的题面进行简化：

  • 给定一个 个点 条边的无向图，要求在图中找出一颗生成树，满足树上的节点到根节点的深度  与该点连到树中的边的权值  之积的和最小。

对于选定节点的每一种局面，我们用一个二进制数进行记录，其每一位上的 表示该点已被选中，反之则没被选中。使用数组  记录当前局面下得最小代价。

显然地，对于每一个可能的根节点  ，有: 

 f[1 << (root - 1)] = 0;
表示初始状态下代价为0。 
 f[(1 << n) - 1];

表示我们要求的目标代价。

由于数据范围很小，我们枚举每个点作为根节点计算 ff 数组，再不断对答案进行更新即可。

代码实现上，我们使用深度优先搜索遍历状态空间，对于每一个状态  ,摘出其中选定的点（位运算的相关操作稍后会进行补充），遍历该点的所有出边，维护一个记录当前点到选定根节点的  数组，一旦得到当前状态的更优方案，就对  数组进行更新，如此往复直到所有状态都被更新完毕为止。

值得注意的是，由于每次枚举根节点都相当于对答案数组重新进行计算，所以务必不要忘记对各个变量进行初始化工作。以及，由于给定的数据范围中点数极少而边数相当的多，在图的储存过程中要注意可能出现的重边情况，此时取长度较短的边保留即可。

AC代码 

#include<iostream>
#include<cstdio>
#include<cctype>
#include<cstring>
#include<queue>
using namespace std;
int read(){
    int re = 0,ch = getchar();
    while(!isdigit(ch))ch = getchar();
    while(isdigit(ch))re = (re<<1) + (re<<3) + ch - '0',ch = getchar();
    return re;
}
int g[13][13],dis[13],f[1<<13];
int n,m,ans = 0x3f3f3f3f;
void dfs(int state){
    for(int i = 1;i <= n;i++){
        if(!((1<<(i-1))&state)) continue;
                //排除不是点集中的边
        for(int j = 1;j <= n;j++){
            if(g[i][j] == 0x3f3f3f3f || j == i) continue;
                        //遍历出边
            if(f[state|(1<<j-1)] > f[state] + g[i][j] * dis[i]){
                        //若可以更新f数组
                int tmp = dis[j];
                dis[j] = dis[i] + 1;
                f[state|(1<<(j-1))] = f[state] + g[i][j] * dis[i];
                dfs(state|(1<<(j-1)));
                                //对新的状态进行递归搜索
                dis[j] = tmp;
                                //回溯
            }
        }
    }
}
int main(){
    n = read(),m = read();
    int u,v,w;
    memset(g,0x3f,sizeof(g));
    for(int i = 1;i <= m;i++){
        u = read(),v = read(),w = read();
        g[u][v] = min(g[u][v],w);
        g[v][u] = min(g[v][u],w);
                //存图与重边处理
    }
    for(int i = 1;i <= n;i++){
        memset(dis,0x3f,sizeof(dis));
        memset(f,0x3f,sizeof(f));
        dis[i] = 1;
        f[1<<(i-1)] = 0;
                //初始化
        dfs(1<<(i-1));
        ans = min(ans,f[(1<<n)-1]);
                //更新答案
    }
    cout << ans;
    return 0;
} 


来源：ICE_Wol