[NOIP2017]宝藏 子集DP

题面：[NOIP2017]宝藏

题面：

　　首先我们观察到，如果直接DP，因为每次转移的代价受上一个状态到底选了哪些边的影响，因此无法直接转移。

　　所以我们考虑分层DP，即每次强制现在加入的点的距离为k（可能实际上小于k），这样就可以忽略掉上个状态选了哪些边的影响了。

　　所以这样为什么是正确的呢？

　　设f[i][j]表示DP到第i层，状态为j的最小代价。（即每层离起点最远的点的距离为i - 1，所以下次转移的点距离为i）

　　那么如果一个点被错误的计算了代价，当且仅当这个点离起点的距离小于i，但我们依然按照i的距离来计算了代价。

　　那么可以证明，这个点一定会在正确的层数被计算一次（i之前的某一层），那么由于当前层数导致代价被多算，因此肯定没那么优，所以不会对答案造成影响。

　　因此我们直接DP即可。

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 15
#define ac 12000
#define inf 2139062143
#define LL long long

int n, m, maxn, ans = inf;
int f[AC][ac], in[AC], g[AC][AC], dis[ac][AC];

inline int read()
{
    int x = 0;char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

inline void upmin(int &a, int b){
    if(b < a) a = b;
}

void pre()
{
    n = read(), m = read(), maxn = (1 << n) - 1;
    memset(g, 127, sizeof(g));
    for(R i = 1; i <= m; i ++)
    {
        int a = read(), b = read(), c = read();
        upmin(g[a][b], c), upmin(g[b][a], c);
    }
    int tmp = 1;
    for(R i = 1; i <= n; i ++)
        in[i] = tmp, tmp <<= 1, g[i][i] = 0;
}

void get()//获取所有联通块到各个点的距离，预处理可以降低复杂度
{
    memset(dis, 127, sizeof(dis));
    for(R k = 1; k <= maxn; k ++)
    {
        for(R i = 1; i <= n; i ++)//枚举集合内的一点
        {
            if(!(k & in[i])) continue;
            for(R j = 1; j <= n; j ++)
            {
                if(k & in[j]) dis[k][j] = 0;
                else upmin(dis[k][j], g[i][j]);
            }
        }
    }
}    

void work()
{
    memset(f, 127, sizeof(f));
    for(R k = 1; k <= n + 1; k ++)//枚举当前层(走下一步的最远距离)
    {
        for(R i = 1; i <= n; i ++) f[k][in[i]] = 0;
        upmin(ans, f[k][maxn]);    
        for(R i = 1; i <= maxn; i ++)//枚举状态
        {
            if(f[k][i] == inf) continue;//不判断这个可能会爆int
            int s = i ^ maxn;//获取补集
            for(R j = s; j; j = (j - 1) & s)//枚举补集的子集
            {
                int tmp = 0;bool flag = true;
                for(R l = 1; l <= n; l ++)
                {
                    if(!(j & in[l])) continue;//如果不在这个子集中就跳过
                    if(dis[i][l] == inf) {flag = false; break;}
                    tmp += k * dis[i][l];
                }
                if(flag) upmin(f[k + 1][i | j], f[k][i] + tmp);
            }
        }
    }
    printf("%d
", ans);
}

int main()
{
//    freopen("in.in", "r", stdin);
    pre();
    get();
    work();
//    fclose(stdin);
    return 0;
}