洛谷P3959 宝藏

去年NOIP第二毒瘤(并不)的题终于被我攻克了，接下来就只剩noip难度巅峰列队了。

首先说一下三种做法：随机化，状压DP和搜索。

前两种做法我都A了，搜索实在是毒瘤，写鬼啊。

有些带DFS的记忆化搜索版状压DP，我看着感觉有点问题......

就连随机化里面那个贪心我看起来也感觉是错的.....但还是A了。

所以考试的时候不要虚，大胆写随机化，随便混个几十分，说不定就A了。

---

20分算法：给定一棵树，枚举根即可。

 #include <cstdio>
 #include <algorithm>

 const int N = , M = , INF = 0x7f7f7f7f;

 int G[N][N], n;

 int DFS(int x, int k, int f) {
     int ans = ;
     for(int i = ; i <= n; i++) {
         if(G[x][i] && i != f) {
             ans += DFS(i, k + , x);
             ans += G[x][i] * k;
         }
     }
     return ans;
 }

 int main() {
     int m;
     scanf("%d%d", &n, &m);
     for(int i = , x, y, z; i <= m; i++) {
         scanf("%d%d%d", &x, &y, &z);
         if(G[x][y]) {
             z = std::min(z, G[x][y]);
         }
         G[x][y] = G[y][x] = z;
     }

     int ans = INF;
     for(int i = ; i <= n; i++) {
         ans = std::min(ans, DFS(i, , ));
     }
     printf("%d", ans);

     return ;
 }

20分代码

40分算法：边权相等，据说可以BFS/DFS/prim，反正我搞不出来....

70分算法：直接枚举全排列，然后按照排列顺序依次加点，贪心即可。

这里有个问题：当前点的深度会对后面节点造成影响，所以贪心出来的不一定是这个顺序的最优解。

但是你有很多排列啊，说不定哪一次就搞出正解来了呢？

 #include <cstdio>
 #include <algorithm>

 const int N = , M = , INF = 0x7f7f7f7f;

 int G[N][N], n, a[N], dis[N];

 int main() {
     int m;
     scanf("%d%d", &n, &m);
     for(int i = , x, y, z; i <= m; i++) {
         scanf("%d%d%d", &x, &y, &z);
         if(G[x][y]) {
             z = std::min(z, G[x][y]);
         }
         G[x][y] = G[y][x] = z;
     }

     for(int i = ; i <= n; i++) {
         a[i] = i;
     }
     int ans = INF;
     do {
         dis[a[]] = ;
         int t_ans = ;
         for(int i = ; i <= n; i++) {
             bool f = ;
             int small = INF, pos;
             for(int j = ; j < i; j++) {
                 if(!G[a[i]][a[j]]) {
                     continue;
                 }
                 f = ;
                 if(small > dis[a[j]] * G[a[i]][a[j]]) {
                     small = dis[a[j]] * G[a[i]][a[j]];
                     pos = j;
                 }
             }
             if(!f) {
                 t_ans = INF;
                 goto flag;
             }
             t_ans += small;
             dis[a[i]] = dis[a[pos]] + ;
         }
         flag:
         ans = std::min(ans, t_ans);
     }while(std::next_permutation(a + , a + n + ));

     printf("%d", ans);
     return ;
 }

AC代码

100分算法_随机化：

把70分算法改进一下，不枚举全排列，而是random_shuffle，说不定哪次就搞出正解来了呢？

然后就真A了......考场上还不是送分送到死啊，反向筛人。跑的还贼快...

 #include <cstdio>
 #include <algorithm>

 const int N = , M = , INF = 0x7f7f7f7f;

 int G[N][N], n, a[N], dis[N];

 int main() {
     int m;
     scanf("%d%d", &n, &m);
     for(int i = , x, y, z; i <= m; i++) {
         scanf("%d%d%d", &x, &y, &z);
         if(G[x][y]) {
             z = std::min(z, G[x][y]);
         }
         G[x][y] = G[y][x] = z;
     }

     for(int i = ; i <= n; i++) {
         a[i] = i;
     }
     int ans = INF, T = ;
     while(T--) {
         std::random_shuffle(a + , a + n + );
         dis[a[]] = ;
         int t_ans = ;
         for(int i = ; i <= n; i++) {
             bool f = ;
             int small = INF, pos;
             for(int j = ; j < i; j++) {
                 if(!G[a[i]][a[j]]) {
                     continue;
                 }
                 f = ;
                 if(small > dis[a[j]] * G[a[i]][a[j]]) {
                     small = dis[a[j]] * G[a[i]][a[j]];
                     pos = j;
                 }
             }
             if(!f) {
                 t_ans = INF;
                 goto flag;
             }
             t_ans += small;
             dis[a[i]] = dis[a[pos]] + ;
         }
         flag:
         ans = std::min(ans, t_ans);
     }

     printf("%d", ans);
     return ;
 }

AC代码

100分算法_状压DP：

好，这个才是这篇博客的主要目的。

我们发现这个深度很难搞啊...

然后又发现同一个深度的话，边权的加权是一定的。

然后我们考虑把边权搞到状态里去，那就是f[i][j][k]表示根为i，最大深度为j，已选节点状态是k的最小权值。

然后发现根那个维度其实可以不要，所以就是f[i][j]表示最大深度为i，目前状态为j的最小权值。

然后转移就是枚举j的子集k，计算出从k扩展成j的最小权值，乘上i即可。

然后发现上面那个计算k->j的最小权值，我们对于每个i都要做一次，所以可以预处理出来。

然后搞一搞一些奇怪的细节，就A了...

具体见代码。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 typedef long long LL;
 const int N = , M = , INF = 0x7f7f7f7f;

 int G[N + ][N + ], n;
 LL f[N + ][ << N], val[ << N][ << N];

 inline void out(int x) {
     for(int i = ; i <= ; i++) {
         printf("%d", (x >> i) & );
     }
     printf("  ");
 }

 int main() {
     int m;
     scanf("%d%d", &n, &m);
     for(int i = , x, y, z; i <= m; i++) {
         scanf("%d%d%d", &x, &y, &z);
         if(G[x][y]) {
             z = std::min(z, G[x][y]);
         }
         G[x][y] = G[y][x] = z;
     }

     int lm =  << n;
     memset(f, 0x3f, sizeof(f));
     memset(val, 0x3f, sizeof(val));
     for(int i = ; i < n; i++) {
         f[][ << i] = ;
     }
     for(int i = ; i < lm; i++)  {
         for(int j = (i - ) & i; j > ; j = (j - ) & i) { // j -> i
             int ans = ;
             for(int k = ; k < n; k++) {
                 if(!(i & ( << k)) || (j & ( << k))) {
                     continue;
                 }
                 int small = INF;
                 for(int l = ; l < n; l++) { // l -> k
                     if(!(j & ( << l)) || !G[l + ][k + ]) {
                         continue;
                     }
                     small = std::min(small, G[l + ][k + ]);
                 }
                 if(small == INF) {
                     ans = INF;
                     break;
                 }
                 ans += small;
             }
             val[j][i] = ans;
         }
     }

     for(int i = ; i <= n; i++) { // deep
         for(int j = ; j < lm; j++) { // state
             for(int k = (j - ) & j; k > ; k = (k - ) & j) { // subset
                 f[i][j] = std::min(f[i][j], f[i - ][k] + val[k][j] * i);
                 /*printf("%d  ", i);
                 out(k);
                 out(j);
                 printf("%lld + %lld \n", f[i - 1][k], val[k][j] * i);*/
             }
         }
     }
     LL ans = 1ll * INF * INF;
     for(int i = ; i <= n; i++) {
         ans = std::min(ans, f[i][lm - ]);
     }
     printf("%lld", ans);
     return ;
 }

AC代码

发现上面一列"然后"......语文水平有待提高啊......