HDU 1693(状态压缩 插头DP)

 

我们引用国家队2008年陈丹琦的大作——《基于连通性状态压缩的动态规划问题》，上面对于插头、轮廓线的概念有详细的解释，不再赘述。

 

我们使用一个三维数组，前两维表示所在的格子，后一维表示轮廓线的状况，值为方案数。

 

在每一行开始前，我们需要把上一行最右的轮廓线转换为这一行最左的轮廓线，因此执行一次左移操作（实际上轮廓线是进行了向右的一次滑动）

 

 

 

然后枚举所在单元格对每个轮廓线的影响 在论文中我们可以发现轮廓线总是包围一个格子的上部分和左部分 我们认为如果有通路与轮廓线重合则为1否则为0

 

 

 

 

因此很容易想象出来（当然也可以看论文）各个状态之间的转移关系 对于可通行的格子 分部分覆盖和全部覆盖以及全部不覆盖的情况讨论

 

对不可通行的格子必须将不可能的覆盖方案置为0 到最后的结果就是所求的方案了即dp[m][n][0]

 

感谢DK大牛的指导 本人5天来的苦思冥想终于得到了成果 1693 0ms 排行统计第一....

 

以下为本人代码:

 

 

#include  < iostream >
using   namespace  std;
typedef __int64 LL;
LL dp[ 12 ][ 12 ][ 1 << 12 ];
long  hash[ 12 ][ 12 ];

int  main()
{
     long  T;
     long  b = 1 ;
    scanf( " %ld " , & T);
     while  (T -- )
    {
         long  i,j,k,m,n;
        scanf( " %ld %ld " , & m, & n);
         for  (i = 1 ;i <= m; ++ i)
        {
             for  (j = 1 ;j <= n; ++ j)
            {
                scanf( " %ld " , & hash[i][j]);
            }
        }

        dp[ 0 ][n][ 0 ] = 1 ;

         for  (i = 1 ;i <= m; ++ i)
        {
             long  len = 1 << n;
             for  (j = 0 ;j < len; ++ j)
            {
                dp[i][ 0 ][j << 1 ] = dp[i - 1 ][n][j];
            }

            
             for  (j = 1 ;j <= n; ++ j)
            {
                len = ( 1 << n << 1 );
                 for (k = 0 ;k < len; ++ k)
                {
                     long  p = 1 << j;
                     long  q = p >> 1 ;
                    
                     bool  x = p & k;
                     bool  y = q & k;

                     if  (hash[i][j])
                    {
                        dp[i][j][k] = dp[i][j - 1 ][k ^ p ^ q];
                         if  (x != y)
                        {
                            dp[i][j][k] += dp[i][j - 1 ][k];
                        }
                    }
                     else
                    {
                         if  (x == 0 && y == 0 )
                        {
                            dp[i][j][k] = dp[i][j - 1 ][k];
                        }
                         else
                        {
                            dp[i][j][k] = 0 ;
                        }
                    }
                }
            }
        }
        printf( " Case %ld: There are %I64d ways to eat the trees.\n " ,b ++ ,dp[m][n][ 0 ]);

    }
     return   0 ;
}

 

 

以下为DK大人的sample代码，我加上了注释：

 

#include < iostream >
using   namespace  std;
int  mat[ 100 ][ 100 ];
__int64 dp[ 12 ][ 12 ][ 1 << 12 ];
int  main()
{
     //  freopen("1.txt","r",stdin);
     int  zu;
     int  g = 1 ;
    scanf( " %d " , & zu);
     while (zu -- )
    {
         int  m,n;
        scanf( " %d%d " , & m, & n);
         int  i,j,k;
         for (i = 1 ;i <= m;i ++ )
             for (j = 1 ;j <= n;j ++ )
                scanf( " %d " , & mat[i][j]);
             // memset(dp,0,sizeof(dp));
            dp[ 0 ][n][ 0 ] = 1 ;
             for (i = 1 ;i <= m;i ++ )
            {
                 for (j = 0 ;j < ( 1 << n);j ++ )
                    dp[i][ 0 ][j << 1 ] = dp[i - 1 ][n][j];
                 // 把最右边的去掉 把所有的状态拉到下一行并进行合理的改变(注意最左边的是低位所代表的数) 
                 // 上一行最右边的边格一定不与轮廓线重合 下一行最左边的边格也一定不与轮廓线重合 
                 // 所以进行的是上一行所有状态(也就是轮廓线)向右的一次滑动
                     for (j = 1 ;j <= n;j ++ ) // 枚举决策线的拐向
                    {
                         for (k = 0 ;k < ( 1 << n << 1 );k ++ ) // 枚举轮廓线
                        {
                             int  p = 1 << j; // 第j个轮廓段(上)
                             int  q = p >> 1 ; // 第j-1个轮廓段(左)
                             bool  x = k & p; // 左轮廓是否与通路相交
                             bool  y = k & q; // 上轮廓是否与通路相交
                            
                             // 判断轮廓线在[i,j]为拐向时的分布 每个格子有1<<n<<1种 多阶段决策
                            
                             if (mat[i][j]) // 如果该单元可以通行
                            {
                                dp[i][j][k] = dp[i][j - 1 ][k ^ p ^ q]; // 必然有一个通路连接上一个格的通路
                                 if (x != y)
                                    dp[i][j][k] += dp[i][j - 1 ][k]; // 有一处新覆盖则有另外的一种情况
                            }
                             else // 否则为障碍格子
                            {
                                 if (x == 0 && y == 0 ) // 通路与轮廓线不相交
                                    dp[i][j][k] = dp[i][j - 1 ][k]; // 直接转移
                                 else
                                    dp[i][j][k] = 0 ; // 通路与轮廓线相交的方案一定为0
                            }
                        }
                    }
            }
            printf( " Case %d: There are %I64d ways to eat the trees.\n " ,g ++ ,dp[m][n][ 0 ]);
    }
     return   0 ;
}