洛谷P3959 宝藏

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

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

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

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

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

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

---

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

#include <cstdio>
#include <algorithm>

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

int G[N][N], n;

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

int main() {
    int m;
    scanf("%d%d", &n, &m);
    for(int i = 1, 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 = 1; i <= n; i++) {
        ans = std::min(ans, DFS(i, 1, 0));
    }
    printf("%d", ans);

    return 0;
}

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

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

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

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

#include <cstdio>
#include <algorithm>

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

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

int main() {
    int m;
    scanf("%d%d", &n, &m);
    for(int i = 1, 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 = 1; i <= n; i++) {
        a[i] = i;
    }
    int ans = INF;
    do {
        dis[a[1]] = 1;
        int t_ans = 0;
        for(int i = 2; i <= n; i++) {
            bool f = 0;
            int small = INF, pos;
            for(int j = 1; j < i; j++) {
                if(!G[a[i]][a[j]]) {
                    continue;
                }
                f = 1;
                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]] + 1;
        }
        flag:
        ans = std::min(ans, t_ans);
    }while(std::next_permutation(a + 1, a + n + 1));

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

100分算法_随机化：

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

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

#include <cstdio>
#include <algorithm>

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

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

int main() {
    int m;
    scanf("%d%d", &n, &m);
    for(int i = 1, 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 = 1; i <= n; i++) {
        a[i] = i;
    }
    int ans = INF, T = 100000;
    while(T--) {
        std::random_shuffle(a + 1, a + n + 1);
        dis[a[1]] = 1;
        int t_ans = 0;
        for(int i = 2; i <= n; i++) {
            bool f = 0;
            int small = INF, pos;
            for(int j = 1; j < i; j++) {
                if(!G[a[i]][a[j]]) {
                    continue;
                }
                f = 1;
                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]] + 1;
        }
        flag:
        ans = std::min(ans, t_ans);
    }

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

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 = 12, M = 1010, INF = 0x7f7f7f7f;

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

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

int main() {
    int m;
    scanf("%d%d", &n, &m);
    for(int i = 1, 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 = 1 << n;
    memset(f, 0x3f, sizeof(f));
    memset(val, 0x3f, sizeof(val));
    for(int i = 0; i < n; i++) {
        f[0][1 << i] = 0;
    }
    for(int i = 1; i < lm; i++)  {
        for(int j = (i - 1) & i; j > 0; j = (j - 1) & i) { // j -> i
            int ans = 0;
            for(int k = 0; k < n; k++) {
                if(!(i & (1 << k)) || (j & (1 << k))) {
                    continue;
                }
                int small = INF;
                for(int l = 0; l < n; l++) { // l -> k
                    if(!(j & (1 << l)) || !G[l + 1][k + 1]) {
                        continue;
                    }
                    small = std::min(small, G[l + 1][k + 1]);
                }
                if(small == INF) {
                    ans = INF;
                    break;
                }
                ans += small;
            }
            val[j][i] = ans;
        }
    }

    for(int i = 1; i <= n; i++) { // deep
        for(int j = 1; j < lm; j++) { // state
            for(int k = (j - 1) & j; k > 0; k = (k - 1) & j) { // subset
                f[i][j] = std::min(f[i][j], f[i - 1][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 = 0; i <= n; i++) {
        ans = std::min(ans, f[i][lm - 1]);
    }
    printf("%lld", ans);
    return 0;
}

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