[atARC078F]Mole and Abandoned Mine

 注意到最终图的样子可以看作一条从1到$n$的路径，以及删去这条路径上的边后，路径上的每一个点所对应的一个连通块

考虑dp，令$f_{S,i}$表示当前1到$n$路径上的最后一个点以及之前点（包括$i$）所对应连通块的并，转移考虑枚举下一个点以及其对应的连通块，即$f_{Scup T,j}=min(f_{S,i}+sum(S,T)-len(i,j))$

（其中$len(i,j)$表示$(i,j)$这条边的长度，$sum(S,T)=sum_{xin S,yin T,(x,y)in E}len(x,y)$）

初始状态为$f_{S,1}=0$（其中$1in S$且$S$的导出子图连通），$f_{other}=infty$

转移条件为$(i,j)in E$、$jin T$、$Scap T=empty$且$T$的导出子图连通，因此转移复杂度为$o(n^{2}3^{n})$（关于$T$导出子图连通的这个条件预处理即可）

进一步优化，关于$j$和$T$的枚举可以分开，即先求出$g_{j}=min(f_{S,i}-len(i,j))$，再枚举包含$j$的$T$即可（这样做的实际意义是先将$S$中所有到$j$的边选择最小的），时间复杂度降为$o(n3^{n})$

#include<bits/stdc++.h>
using namespace std;
#define N 15
struct ji{
    int nex,to,len;
}edge[N*N];
int E,n,m,x,y,z,head[N],vis[N],g[N],con[1<<N],sum[1<<N],f[1<<N][N];
void add(int x,int y,int z){
    edge[E].nex=head[x];
    edge[E].to=y;
    edge[E].len=z;
    head[x]=E++;
}
void dfs(int k,int s){
    if (((s&(1<<k))==0)||(vis[k]))return;
    vis[k]=1;
    for(int i=head[k];i!=-1;i=edge[i].nex)dfs(edge[i].to,s);
}
int main(){
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof(head));
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&x,&y,&z);
        add(x-1,y-1,z);
        add(y-1,x-1,z);
    }
    memset(f,0x3f,sizeof(f));
    for(int i=0;i<(1<<n);i++){
        memset(vis,0,sizeof(vis));
        for(int j=0;j<n;j++)
            if (i&(1<<j)){
                dfs(j,i);
                break;
            }
        bool flag=0;
        for(int j=0;j<n;j++)
            if ((i&(1<<j))&&(!vis[j])){
                flag=1;
                break;
            }
        if (!flag){
            con[i]=1;
            if (i&1)f[i][0]=0;
        }
    }
    for(int i=1;i<(1<<n);i+=2){
        if (!con[i])continue;
        for(int x=0;x<n;x++){
            g[x]=0x3f3f3f3f;
            sum[(1<<x)]=0;
        }
        for(int x=0;x<n;x++)
            if ((i&(1<<x))){
                for(int j=head[x];j!=-1;j=edge[j].nex){
                    y=edge[j].to;
                    if ((i&(1<<y))==0){
                        g[y]=min(g[y],f[i][x]-edge[j].len);
                        sum[(1<<y)]+=edge[j].len;
                    }
                }
            }
        int ii=(1<<n)-1-i;
        for(int j=(ii&(ii-1));j>=0;j=((j-1)&ii)){
            int jj=(ii^j),k=(jj&(jj-1));
            sum[jj]=sum[jj^k]+sum[k];
            if (jj==ii)break;
        }
        for(int x=0;x<n;x++)
            for(int j=ii;j;j=((j-1)&ii))
                if ((j&(1<<x))&&(con[j]))f[i|j][x]=min(f[i|j][x],g[x]+sum[j]);
    }
    printf("%d",f[(1<<n)-1][n-1]);
}