HDU 3001 三进制状态压缩

原文链接: HDU 3001 三进制状态压缩

上一篇: POJ 3311

下一篇: ZOJ 4257

参照poj 3311

题目中明确的说了每个点最多走2次，也就是说压缩为二进制并不能直接求出结果了，因为二进制只能代表一个点是否被走过的状态，而具体走过了几次却并不能记录！！然而我们题目要求可以走两次呀！怎么办？！大牛们想到了办法，压缩为三进制！

将状态压缩为三进制之后，那么显然，我们的状态数增多了，那么这些增加的状态数代表着什么呢？

举个栗子：将46化为3进制之后是1201，那么我们就可以暴力的来表示第1个点去过1次，第2个点没去过，第3个点去过2次，第4个点也去过1次！

用上面这个例子来说明一个问题，就是我们用三进制来压缩了题目要求的所有的状态，因为每个数位可以是2了，这个2是有意义的！就是表示某个点是否去过2次！

然后dp部分是状态压缩的常规解法，主要在于理解为何要化为3进制的状态压缩。

#include <cstdio>
#include <cstring>
#define INF 0x1f1f1f1f//刚发现这里写0x1f1f1f跑的比0x1f1f1f1f差不多慢了一倍！Orz~
#define min(a, b) (a) < (b) ? (a) : (b)
using namespace std;

int N, M;
int tri[12] = {0, 1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049};
int dig[59050][11];//dig[state][k_dig]  状态state的第k位是多少
int edge[11][11], dp[59050][11];

int main(){
    for (int i = 0; i < 59050; ++i){
        int t = i;
        for (int j = 1; j <= 10; ++j){
            dig[i][j] = t % 3;
            t /= 3;
            if (t == 0) break;
        }
    }

    while (scanf("%d%d", &N, &M) != EOF){
        memset(edge, INF, sizeof(edge));

        int a, b, c;
        while (M--){
            scanf("%d%d%d", &a, &b, &c);
            if (c < edge[a][b]) edge[a][b] = edge[b][a] = c;
        }

        memset(dp, INF, sizeof(dp));

        for (int i = 1; i <= N; ++i) 
        dp[tri[i]][i] = 0;
        int ans = INF;
        for (int S = 0; S < tri[N + 1]; ++S){
            int visit_all = 1;
            for (int i = 1; i <= N; ++i){
                if (dig[S][i] == 0) visit_all = 0;
                if (dp[S][i] == INF) continue;

                for (int j = 1; j <= N; ++j){
                    if (i == j) continue;
                    if (edge[i][j] == INF || dig[S][j] >= 2) continue;
                    int newS = S + tri[j];
                    dp[newS][j] = min(dp[newS][j], dp[S][i] + edge[i][j]);
                }
            }
            if (visit_all){
                for (int j = 1; j <= N; ++j)
                    ans = min(ans, dp[S][j]);
            }

        }
        if (ans == INF){
            puts("-1\n");
            continue;
        }
        printf("%d\n", ans);
    }
    return 0;
}

将点换为由0开始标号

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>

#define LL long long
int const MAX = 1e6 + 1;
int const INF = 1 << 30;
double const EPS = 0.00000001;
using namespace std;

//three[i] 表示第i位是1的3进制数
int dis[10][10], three[11], digit[59050][10], dp[59050][10], n, m;

void init(){
    three[0] = 1;
    //有十个点
    for (int i = 1; i < 11; i++)
        three[i] = 3 * three[i - 1];
    for (int i = 0; i < 59050; i++){
        int t = i;
        for (int j = 0; j < 10; j++){
            digit[i][j] = t % 3;
            t /= 3;
        }
    }
}
int main(){
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);

    init();
    // for (int i = 0; i < 10; i++)
    //     printf("%d ", three[i]);
    // for (int i = 0; i < 10; i++){
    //     printf("\n%d: ", i);
    //     for (int j = 0; j < 10; j++)
    //         printf("%d ", digit[i][j]);
    //
    // }

    while (scanf("%d%d", &n, &m) == 2){
        for (int i = 0; i < three[n]; i++)
            for (int j = 0; j < n; j++)
                dp[i][j] = INF;
        for (int i = 0; i < 10; i++)
            for (int j = 0; j < 10; j++)
                dis[i][j] = INF;
        while (m--){
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            dis[a - 1][b - 1] = dis[b - 1][a - 1] = min(c, dis[a - 1][b - 1]);
        }

        //每个点到自己的距离为0
        for (int i = 0; i < n; i++)
            dp[three[i]][i] = 0;

        int ans = INF;

        //最外层循环是走过的点数
        //由dp[state][i]更新能到达的点
        for (int state = 0; state < three[n]; state++){
            bool vis_all = 1;
            for (int i = 0; i < n; i++){
                if (digit[state][i] == 0) vis_all = 0;
                if (dp[state][i] == INF) continue;

                //能更新的点
                for (int j = 0; j < n; j++){
                    if (i == j || dis[i][j] == INF || digit[state][j] == 2)
                        continue;

                    int nstate = state + three[j];
                    dp[nstate][j] = min(dp[nstate][j], dp[state][i] + dis[i][j]);
                }
            }
            if (vis_all)
                for (int k = 0; k < n; k++)
                    ans = min(ans, dp[state][k]);
        }

        if (ans == INF)
            printf("-1\n");
        else
            printf("%d\n", ans);
    }
    return 0;
}