Luogu3959 NOIP2017 宝藏 状压DP

题目传送门：https://www.luogu.org/problemnew/show/P3959

题意：给出一个有$N$个点的图，求其中的一个生成树（指定一个点为根），使得$\sum\limits_{i=1}^{N-1} v_i \times dep_i$最小，其中$v_i$为生成树上某条边的边权，$dep_i$为这条边连接的两个点中深度较浅的点的深度。$N \leq 12 , v \leq 5 \times 10^5$

---

$N \leq 12$给我们一个很强烈的信息：状态压缩

（所以这题还可以用暴力枚举+可持久化并查集拿90pts，用%你退火和诡异贪心拿到满分）

我们不妨考虑一层一层加入点

设$g_{i,j}$表示点集$j$向点集$i$每个点连一条边的最小权值和，可以在$O(3^NN^2)$的复杂度内算出（似乎可以优化成$O(3^NN)$）

然后设$f_{i,j}$表示现在的生成树中有$i$层节点，其中深度最深的节点集合为$j$时的最小权值，考虑转移为$f_{i+1,k}=f_{i,j}+g_{j,k}$

最后答案为$min\{f_{k,(1<<N)-1}\}$

复杂度为$O(3^NN^2)$，实际可优化成$O(3^NN)$

 // luogu-judger-enable-o2
 #include<bits/stdc++.h>
 #define MAXN (1 << 12) + 1
 using namespace std;

 inline int read(){
     ;
     char c = getchar();
     while(!isdigit(c))
         c = getchar();
     while(isdigit(c)){
         a = (a << ) + (a << ) + (c ^ ');
         c = getchar();
     }
     return a;
 }

 inline int min(int a , int b){
     return a < b ? a : b;
 }

 ][MAXN] , route[][];

 int main(){
     memset(route , 0x3f , sizeof(route));
     memset(g , 0x3f , sizeof(g));
     int N = read() , M = read();
     ){
         cout << ;
         ;
     }
      ; i < N ; i++)
         g[][ << i] = ;
     while(M--){
         int a = read() , b = read() , c = read();
         route[a][b] = route[b][a] = min(route[a][b] , c);
     }
      ; i <  << N ; i++){
          << N) - ) ^ i;
          & s){
             int p = j;
             for(int k = p & -p ; p ; k = p & -p){
                 int minN = 0x3f3f3f3f;
                 p -= k;
                  , q = i;
                 for(int m = q & -q ; q ; m = q & -q){
                     q -= m;
                     minN = min(minN , route[t][(]);
                 }
                 if(minN == 0x3f3f3f3f){
                     f[i][j] = 0x3f3f3f3f;
                     break;
                 }
                 f[i][j] += minN;
             }
         }
     }
      ; i < N ; i++)
          ; j <  << N ; j++){
             if(j == (j & -j))
                 continue;
              & j ; k ; k = k -  & j)
                 ][j ^ k] != 0x3f3f3f3f)
                     g[i][j] = min(g[i][j] , g[i - ][j ^ k] + f[j ^ k][k] * i);
         }
     int all = 0x7fffffff;
      ; i < N ; i++)
         all = min(all , g[i][( << N) - ]);
     cout << all;
     ;
 }