POJ 2596 Dice Stacking

S表示已用骰子的集合。

dp[S][i][j]表示在当前集合下，最上面那个骰子为 i ，底面编号为 j 时所能得到的最大和, max[i][j] 表示骰子 i 以 j 为底时侧面的最大值，dice[i][j]表示 i 骰子 j 面的编号。

dp[S][i][j] = max{ dp[ S ^ ( 1 << i ) ][k][m]+max[i][j] };

k∈(S ^ ( 1 << i ) ), dice[k][5 - m]==dice[i][j]。

为了方便判断相对的面，存储时处理一下，使得相对的面存储在编号加和为5的位置中。

即如果 a, b 面相对，则 a + b = 5

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

using namespace std;

int N;
int dice[12][6];
int ans;
int dp[ 1 << 11 ][12][6];
bool vis[ 1 << 11 ][12][6];

int DFS( int S, int j, int botm )
{
    bool& flag = vis[S][j][botm];
    int& res = dp[S][j][botm];

    if ( flag ) return res;

    res = -(1 << 30);
    for ( int k = 0; k < N; ++k )
        if ( k != j && ( S & ( 1 << k ) ) )
        {
            for ( int m = 0; m < 6; ++m )
            {
                //printf("dice[%d][%d]=%d dice[%d][%d]=%d\n", k, m, dice[k][m], j, botm, dice[j][botm] );
                if ( dice[k][m] == dice[j][botm] )
                {
                    int maxi = 0;
                    for ( int kk = 0; kk < 6; ++kk )
                        if ( kk != botm && kk + botm != 5 )
                            maxi = max( maxi, dice[j][kk] );
                    //printf("maxi=%d\n", maxi);
                    //printf( "dp[%d][%d][%d] = %d\n", S, j, botm, res );
                    res = max( res, DFS( S ^ ( 1 << j ), k, 5 - m ) + maxi );
                    //printf( "**dp[%d][%d][%d] = %d\n", S, j, botm, res );
                    //printf("res=%d\n", res);
                }
            }
        }

 //   printf( "dp[%d][%d][%d] = %d\n\n", S, j, botm, res );

    flag = true;

    return res;
}

void init()
{
    for ( int i = 0; i < N; ++i )
    {
        for ( int j = 0; j < 6; ++j )
        {
            int maxi = 0;
            for ( int m = 0; m < 6; ++m )
                if ( m != j && j + m != 5 ) maxi = max( maxi, dice[i][m] );

            dp[ 1 << i ][i][j] = maxi;
            vis[ 1 << i ][i][j] = true;
        }
    }
    return;
}


int main()
{
    //freopen("s.out", "w", stdout );
    int T;
    scanf( "%d", &T );
    while ( T-- )
    {
        scanf( "%d", &N );
        for ( int k = 0; k < N; ++k )
        {
            for ( int i = 0; i < 6; ++i )
                scanf( "%d", &dice[k][i] );

            int tp = dice[k][3];
            dice[k][3] = dice[k][4];
            dice[k][4] = tp;
        }

        ans = 0;
        memset( vis, false, sizeof(vis) );
        memset( dp, 0, sizeof(dp) );

        init();

        for ( int i = 0; i < N; ++i )
            for ( int j = 0; j < 6; ++j )
            {
                DFS( ( 1 << N ) - 1, i, j );
                ans = max( ans, dp[ (1 << N) - 1 ][i][j] );
            }

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

吐槽：

一开始看 n<= 10 直接当成搜索来搞了……于是理所应当的TLE……

后来明白是个跟集合有关的DP，用的记忆化搜索，结果各种细节出错……初始化边界错，判断条件错，改了一个半小时才过，我勒个去去去去……