poj-2411

最新推荐文章于 2021-08-10 19:37:33 发布
最新推荐文章于 2021-08-10 19:37:33 发布
阅读量484 收藏
点赞数
分类专栏： POJ 文章标签： poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fyfcauc/article/details/29869031
版权 
#include <stdio.h>

long combineNum[12][2049];

long long combineNumLastRow[12][2049];

// void getCombineNum() {
//     for (int i = 1; i <= 11; i++) {
//         for (int j = 0; j <= 2047; j++) {
//             if (j > pow(2, i) - 1) {
//                 combineNum[i][j] = 0;
//             } else if (i == 1) {
//                     combineNum[i][j] = 1;
//             } else if (i == 2) {
//                 if (j == 0) {
//                     combineNum[i][j] = 2;  // 1. -- 2. ||
//                 } else if (j == 1) {
//                     combineNum[i][j] = 1;
//                 } else if (j == 2) {
//                     combineNum[i][j] = 1;
//                 } else if (j == 3) {
//                     combineNum[i][j] = 1;
//                 }
//             } else {
//                 int first2Bit = j & 0x3;

//                 switch (first2Bit) {
//                     case 0:
//                         combineNum[i][j] = combineNum[i-1][j>>1] + combineNum[i-2][j>>2];
//                         break;
//                     case 1:
//                         combineNum[i][j] = combineNum[i-1][j>>1];
//                         break;
//                     case 2:
//                         combineNum[i][j] = combineNum[i-2][j>>2];
//                         break;
//                     case 3:
//                         combineNum[i][j] = combineNum[i-2][j>>2];
//                         break;
//                 }
//             }
//         }
//     }
// }

void getCombineNumLastRow() {
    for (int i = 1; i <= 11; i++) {
        for (int j = 0; j <= 2047; j++) {
            if (j > (2<<(i-1)) - 1) {
                combineNumLastRow[i][j] = 0;
            } else if (i == 1) {
                if (j == 0) {
                    combineNumLastRow[i][j] = 0;
                } else if (j == 1) {
                    combineNumLastRow[i][j] = 1;
                }
            } else if (i == 2) {
                if (j == 0) {
                    combineNumLastRow[i][j] = 1;  // 1. --
                } else if (j == 1) {
                    combineNumLastRow[i][j] = 0;
                } else if (j == 2) {
                    combineNumLastRow[i][j] = 0;
                } else if (j == 3) {
                    combineNumLastRow[i][j] = 1;
                }
            } else {
                int first2Bit = j & 0x3;

                switch (first2Bit) {
                    case 0:
                        combineNumLastRow[i][j] = combineNumLastRow[i-2][j>>2];
                        break;
                    case 1:
                        combineNumLastRow[i][j] = combineNumLastRow[i-1][j>>1];
                        break;
                    case 2:
                        combineNumLastRow[i][j] = 0;
                        break;
                    case 3:
                        combineNumLastRow[i][j] = combineNumLastRow[i-2][j>>2];
                        break;
                }
            }
        }
    }
}

bool checkIfMatch(int upRowStatus, int currentRowStatus, int width, int rowMax) {
    
    if ((upRowStatus¤tRowStatus) != 0) {
        return false;
    }
    int tmp = currentRowStatus;
    int tmp1 = upRowStatus;

    int zeroNum = 0;
    int i;
    for (i = 0; i < width; i++) {
        char lowBit = 0x00000001 & currentRowStatus;
        char upperLowBit = 0x00000001 & upRowStatus;
        if (upperLowBit == 1) {
            if (lowBit == 1) {
                return false;
            } else {
                if (zeroNum%2 == 0) {
                    zeroNum = 0;
                } else {
                    return false;
                }
            }           
        } else {
            if (lowBit == 1) {
                if (zeroNum%2 == 0) {
                    zeroNum = 0;
                } else {
                    return false;
                }
            } else if (lowBit == 0) {
                zeroNum++;
            }
        }

        currentRowStatus = currentRowStatus>>1;
        upRowStatus = upRowStatus>>1;
    }
    if (i == width) {
        if (zeroNum%2 != 0) {
            return false;
        }
    }
    return true;
}

bool checkIfValidFirstRow(int rowStatus, int width, int rowMax) {
    int tmp = rowStatus;

    int zeroNum = 0;
    int i;
    for (i = 0; i < width; i++) {
        char lowBit = 0x00000001 & rowStatus;
        if (lowBit == 1) {
            if (zeroNum%2 == 0) {
                zeroNum = 0;
            } else {
                return false;
            }
        } else if (lowBit == 0) {
            zeroNum++;
        }
        rowStatus = rowStatus>>1;
    }
    if (i == width) {
        if (zeroNum%2 != 0) {
            return false;
        }
    }
    return true;
}

void getCount(int height, int width) {
    int rowMax = (2<<(width-1)) - 1;
    long long DP[12][2049] = {0};
    if (height == 1) {
        printf("%lld\n", combineNumLastRow[width][0]);
        return;
    }
    for (int i = height - 1; i >= 1; i--) {
        for (int j = 0; j <= rowMax; j++) {
            if (i == height - 1) {
                DP[i][j] = combineNumLastRow[width][j];
            } else {
                long long sum = 0;
                int addtime = 0;
                for (int k = 0; k <= rowMax; k++) {
                    if (checkIfMatch(j, k, width, rowMax)){
                        // if (j == 1 && i == 1) {
                        //     printf("check %d %lld\n", k, DP[i+1][k]);
                        // }
                        sum += DP[i+1][k];
                        addtime++;
                    }
                }
                // if (i == 1) {
                //     printf("j %d addtime %d\n", j, addtime);
                // }
                DP[i][j] = sum;
            }
        }
    }
    
    long long sum = 0;
    for (int i = 0; i <= rowMax; i++) {
        if (checkIfValidFirstRow(i, width, rowMax)) {
            sum += DP[1][i];
            // printf("%lld i %d\n", DP[1][i], i);
        }
    }
    printf("%lld\n", sum);
}

int main() {
    getCombineNumLastRow();
    while(1) {
        int height, width;
        scanf("%d %d", &height, &width);
        if (height == 0 && width ==0) {
            return 0;
        }
        getCount(height, width);
    }

}



2097ms

憋了几天， 正好工作又忙， 这道题彻底认识到了自己在思维全面性的不足。

用的是常规做法 压缩状态的DP， 压缩状态其实到还不是什么高阶技能， 之前做水题涉及到存储一个小矩形的时候已经用上了，说白了就是编码的本质，

二进制罢了.

关键我最开始根本没有想到以行为单位进行DP， 老想着以一格为单位进行分析， 这样的话， 就算压缩状态也救不了我， 11*11个位， 用128位变量？， 绝对不是这道题的做法。

后来忍不住稍微搜了下， 才发现可以以行为单位分析（唉， 组合数学要补呀， 当时咋就没想到呢， 当然， 用列也可以， 但是本质上是一样的）

某一行的组合状态是一个特定状态， 那么整个长方形的组合状态就是一个特定状态, 不管其他行怎么的排法， 其实相同了很简单， 组合的本质嘛， 某一个特定位置的特定值就可以表示一个整的特定状态（当然， 是从数量上讲）.

然后就是该怎么表示了， 很自然的想到， 横排的格子全部为0， 竖排的全部为1， 咋一看很合理， 但是后来发现， 这样的话，根本体现不出来上一行对下一行的影响了。

比如

1100

这一行， 他既可以是 两个向上竖排加上一个横排， 也可以是两个向下竖排将上一个横排， 下一行的状态不能被上一行正确的影响了。后来钻了牛角尖， 甚至想到统计当前行的某一列累计1和0的奇偶性来表示向上和向下横排， 后来也作罢。

后来才想到， 从对下一排的排列有无直接影响作为区分， 如果是横排说这上竖排，那么显然对下一行的对应列没有影响， 那么就可以用0表示， 而下竖排显然影响了下一行对应列（下行对应列不能再放了）， 那么就是1.

得到了表示方式， 下一步就是求上一行是这种状态， 下一行能有多少个可能的状态了， 这一步思想也简单，只要这一行为1的列（下竖排）和上一行是1的列（上竖排）之间的空隙都是偶数个0（不然如果是奇数个零，那么必有一个空格没法用长度为2的横排填）就是满足需求的组合， 特殊的是最后一行， 最后一行不能再有下竖排， 那么就必须是上一行上竖排的对应列之间的0数为偶数. 最后一行的每种状态组合数记下来，combineNumLastRow。

这样利用DP

第i行(第一行要特殊处理， 不能有上竖排)某个状态j， D[i][j] 就有这样的规律：

如果只有一行（可以认为上一行对齐没有任何影响， 0这个状态）， 那么直接用前面求出最后一行为0的可能组合数就可以了.

如果i是倒数第二行， 那么D[i][j] = combineNumLastRow[width][j]， 及最后一行在长度为width的情况下， 上一行为j的情况下的组合数。

对于其他的行i,  这时候， 就体现出空间换时间了， 既可以把此状态对应的下一行可能的状态保存（花费空间）， 直接遍历， 也可以直接遍历k: 0 ~ (2<<width-1)-1,

逐个排查（花费时间）是否能适应当前行的状态， 如果能， 那么就加上此下一行状态D[i+1][k]的组合数。


在最后求总的组合数， 也不能简单的把D[1][k](k: 0 ~ (2<<width-1)-1 ) 相加， 要注意，第一行和中间行也是不一样的， 第一行是不能有上竖排的， 因此， 在累加的时候也要做一次筛选（其实这一步应该是可以省去的， 应该有更好的办法，在DP的时候就跳过去）。

最后终于以2097mx AC，和期望的差不多， 必定是耗时的。

看disscuss有神人用了25行搞定， 一定要研究研究。

这道题， 如果位运算用的熟练的话，是用不了那么多代码的. 看样子还只有刷题才能提高呀， 工作这几年，基本是遇不到这些需求的，更多的是一种实现的规划和组织. 不过也没准是屠龙之技？算了，

好歹找工作有用.

fyfcauc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ 2411 Mondriaan's Dream详细解题报告
07-12
里面有非常详细的对于POJ 2411的解题报告，相信对于初学动态规划和深度优先搜索的同学来说有很好的帮助作用。
POJ - 2411 (状压dp)
yzyyylx的博客
10-16 352
题面题意 输出用1*2的矩形填满m *n的矩形的方法数 方法 状态压缩,用二进制数表示每一层,枚举当这一层上面全部被填满后该状态的种类数,并且预先处理好上一层为哪些状态时,可以转化为这一层,其中限定每一层只有横着放和竖着(穿过这一层和上一层)两种方法,故若两层对比时,两边的同一格都未放则无法转化,若两层的同一个都放了的这些位置的长度为奇数时,也不行. 最后每行枚举上一行可以的状态,并相
【poj 2411】Mondriaan's Dream　题意＆题解＆代码（Ｃ＋＋）
曾经追梦的happy时光
04-19 788
poj dp 状压
poj2411--Mondriaan's Dream(状压dp+dfs)
随风的专栏
02-04 1454
Mondriaan's Dream Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 12315   Accepted: 7189 Description Squares and rectangles fascinated the famous Dutch painter
POJ - 2411 Mondriaan‘s Dream 蒙德里安的梦想 (状压dp入门经典)
SharpEdges
08-10 193
题目链接 状压dp的含义大致可以这么理解：我们表示的状态是一个十进制数，但是我们要把它看作一个二进制数，所以要先掌握位运算知识 大致思路: 总的方案数等于，只放横着的小方块的合法方案数，因为如果合法，剩下的格子必定能放满竖着的小方块 f[i][j]表示的是前i-1列已经摆好了，且从i-1列伸出小方块到i列的方案总数 重点是代码，其实思路并不难理解，但是由于涉及到位运算，在下由于是因为状压dp才大量接触到位运算，所以直接看代码不能很能理解。注释写得比较详细，建议多看代码和注释 此博文建议是明白了这道题的
poj-problem.rar_poj
09-22
poj的结题报告，里面有一些详细的说明。poj的结题报告，里面有一些详细的说明
POJ-2151.rar_poj
09-21
POJ 2151 Check the difficulty of problems. Practice for dynamic planning.
poj-1009.rar_poj
09-23
POJ 北大在线代码判断,参考答案请参考
POJ-1170.rar_poj
09-22
POJ 1170 动态规划。欢迎各种交流讨论。
poj-1028-Web-Navigation.zip_poj
09-21
poj 1028 Web Navigation 的代码，已通过!
poj2411 棋盘覆盖
GAUSS_CLB
03-07 2449
Mondriaan's Dream Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 12395   Accepted: 7233 Description Squares and rectangles fascinated the famous Dutch pai
POJ 2411(轮廓线dp or 状态压缩dp)
weixin_43958964的博客
03-24 424
题目：click 题意：给定一个长，宽为n,m的矩阵，放满1*2的矩形小块问有多少种方法填满。 范围很小，轮廓dp可以做。 k5 k4 k3 k2 k1 状态改写为如上k5k4k3k2k1去表示，1表示这个格子已经放了，0表示没放。（代码中的状态表示也是这个顺序） 什么是轮廓线？ 图中的红色线就是边缘线，由此来进行状态转移。我们对每一个格子进行状态的分析，我们从左上...
poj2411之用1*2砖块铺满n*m-状态压缩dp
热门推荐
Stephen
03-21 1万+
Mondriaan's Dream Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 10549   Accepted: 6135 Description Squares and rectangles fascinated the famous Dutch pai
POJ 2411 - 状压DP详解
P19777的博客
08-01 1032
poj：http://poj.org/problem?id=2411 这个题属于状态压缩的一个入门题，在讲解该题之间我们先简单的回顾一下状压DP。 注意再看这个题之前，一定要对动态规划有一定的掌握 状压DP： 与传统的DP一样，状压DP也是定义状态，通过前一阶段的状态，推出当前阶段的状态。但是有时候状态特别多，但是每个状态的决策又非常少，我们如果用多维数组来表示状态会造成空间浪费，也可能会...
POJ 2411（状压dp）
HumveeA6的博客
02-12 274
用f[i][j]表示第i行形态为j时，前i行的分割方案总数，j是用十进制记录的m位二进制数，j的第k位为1表示第k列是一个竖着的1*2长方形的上面一半，第k位为0表示其他情况 第i-1行形态k能转移到第i行j有两个要求： 1.k&amp;j==0 这保证了每个1 下面一定是0，即继续补全竖着的1*2的长方形 2.k|j中的0一定是成对出现的 （每一段连续的0必然有偶数个），保证横着放1*2...
POJ2411 状态压缩DP
code
02-20 9602
POJ2411 Mondriaan's Dream 给你n*m（1矩阵，要求用1*2的多米诺骨牌去填充，问有多少种填充方法。 分析： 首先我们定义如下这种填充表示方式：如果一个骨牌是横着放的，那么它所在的两个方格都填充1.如果它是竖着放的，那么它所在的两个格子中，上面的那个填0，下面的这个填1.如下图所示：   由此可以得到断言：该矩阵的骨牌摆放方法和该矩阵的二进制表示法是一一对应的。
poj2411 2663 2420 dp+状态压缩（多米诺骨牌问题）
我只想做一个努力的人
04-19 1万+
题目描述：用1*2 的矩形通过组合拼成大矩形，求拼成指定的大矩形有几种拼法。 首先 我们先求用1*2 的矩形拼成 n*m的矩形有多少种拼法 当n*m为奇数时，一定是不会拼出来的，因为想要拼出来就需要整数倍的小矩形数目。 为了加速算法，要把m，n中小的那个当做列 分两个步骤：1） 先求出相邻两行的转化关系              2） 通过相邻两行的转化关系算出经过n次转化有几种方法能拼
Mondriaan's Dream（POJ-2411）
Alex_McAvoy的博客
08-21 719
Problem Description Squares and rectangles fascinated the famous Dutch painter Piet Mondriaan. One night, after producing the drawings in his 'toilet series' (where he had to use his toilet paper to...
poj 2411 (状压DP经典题）
weixin_45539557的博客
06-12 680
题意： 用1x2的矩形填充n*m的矩形，问填充的方法 思路： 状压DP，画图可以发现，对于每个小正方形块，他只有下图这4种情况 而对于下面有影响的只有他本身作为竖着的上面的一块的时候。所以我们把这时候的块设为1，其他设为0，所以不难得出，当上面为1，下面 必须为0，所以上下二进制数之与必须得是0，又因为是1*2，所以上下之或的结果中，连续0的数必须得是偶数，我们可以预处理出这些数，dp[i][j]表示第i行状态为j的时候的方案数，然后O(n 4^m)枚举即可 #include<iostream>
POJ - 1661
最新发布
09-18
根据提供的引用内容，这个问题讨论的是POJ-1661题，这是一个dp问题。题目给定了一系列平台的高度和人的起始位置，要求从起始位置跳到地面的最短时间。通过设置状态dp[i]表示从第i个平台的左边跳到地面所需的最小时间，dp[i]表示从第i个平台的右边跳到地面所需的最小时间，然后分别计算左右走所需的最小时间，最后取左右走中的较小值作为结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值