[hihocoder1048]状态压缩2

最新推荐文章于 2019-01-17 20:33:30 发布
最新推荐文章于 2019-01-17 20:33:30 发布
阅读量276 收藏
点赞数
分类专栏： hihocoder 文章标签： hihocoder 状态压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/silent56_th/article/details/53611631
版权

问题描述

具体介绍请参考 hihocoder的官网。

算法&部分代码

这里标记中使用的上下左右指的是同一蛋糕的另外一个格子相对于本格子的位置，例如左上角的格子只可能有DOWN和RIGHT两个方向。

1. 深搜+剪枝

从上到下，从左到右，枚举格子的状态，深搜到底则+1。剪枝是基于祖先节点的情况不存在，则本节点的情况也不存在。
深搜是利用迭代算法实现的。简单证明可以得到O(4^n^m)的复杂度，剪枝后的复杂度未思考，但是测试中当n>20就有1s以上的延时，提交后也超时。 
enum {
    NONE,
    UP,
    DOWN,
    LEFT,
    RIGHT
};

bool incre(int &i,int &j,int n,int m){
    if (i == n-1 && j == m-1)
        return false;
    if (++j == m){
        ++i;
        j = 0;
    }
    return true;
}

void decre(int &i,int &j,int n,int m){
    if (j == 0){
        --i;
        j = m-1;
    }
    else
        --j;
}

int times(int n,int m){
    int status[1000][5] = {0};
    int i = 0,j = 0,result = 0;
    bool forw = true;
    while (i > -1 && j > -1){
        if (status[i][j] == NONE){
            if (j < m-1 && status[i][j+1] == NONE)
                status[i][j] = RIGHT;
            else if (i < n-1 && status[i+1][j] == NONE)
                status[i][j] = DOWN;
        }
        else if (status[i][j] == RIGHT) {
            status[i][j+1] = NONE;
            if (i < n-1 && status[i+1][j] == NONE)
                status[i][j] = DOWN;
            else
                status[i][j] = NONE;
        }

        else if (status[i][j] == DOWN){
            status[i][j] = NONE;
            status[i+1][j] = NONE;
        }

        if (status[i][j] == NONE){
            decre(i,j,n,m);
            forw = false;
        }
        else {
            if (status[i][j] == RIGHT){
                status[i][j+1] = LEFT;
                incre(i,j,n,m);
                forw = true;
            }
            else if (status[i][j] == DOWN){
                status[i+1][j] = UP;
                incre(i,j,n,m);
                forw = true;
            }
            else {
                if (forw){
                    if (!incre(i,j,n,m)){
                        if (++result == 1000000007)
                            result = 0;
                        decre(i,j,n,m);
                        forw = false;
                    }
                }
                else
                    decre(i,j,n,m);
            }
        }
    }
    return result;
}

2. 未剪枝的动态规划

逐行枚举，每行有4^m个状态，表示当前行每个格子的4种状态的组合下，对应可以有多少种可能摆放。
进行过程中，每行对于该行以及前一行共两行格子的状态（共8^m个）逐一枚举，如果状态成立，则累加，否则不累加。
可以逐行枚举进行动态规划的原因是每一行的状态成立与否，只受上一行影响，且只影响下一行。
未剪枝的动态规划的时间复杂度是O(n*8^m)，这里存在一个m的指数项，但由于m最大为5，则2^15~32000，大致等于常数项。

因为m的数目不定，而且每个格子只对应于4个状态，不适合用整形数组存储状态组合。这里就利用了 状态压缩，用一个数字存储状态。
其中由右到左第2i与第2i+1个数字位表示该行从左到右第i个格子的状态，00表示UP，01表示DOWN，10表示LEFT，11表示RIGHT。（都是从0开始数） 
int top[1<<10];
int top2[1<<10];
bool flags[1<<20];

void init_flags(int m){
    int len2 = 1<<(2*2*m),tmp_status;
    bool flag;
    for (int j = 0;j < len2;++j){
        flag = true;
        for (int k = 0;k < m && flag;++k){
            tmp_status = (j >> (2*k)) & 3;
            if (tmp_status == 0 && ((3 & (j>>(2*(k+m)))) != 1))
                flag = false;
            else if (tmp_status == 2 && (k == 0 || ((3 & (j>>(2*(k-1)))) != 3)))
                flag = false;
            else if (tmp_status == 3 && (k == m-1 || ((3 & (j>>(2*(k+1)))) != 2)))
                flag = false;
            else if (tmp_status != 0 && ((3 & (j>>(2*(k+m)))) == 1))
                flag = false;
            else if ((tmp_status != 2 && (k > 0 && ((3 & (j>>(2*(k-1)))) == 3))))
                flag = false;
            else if (tmp_status != 3 && (k < m-1 && ((3 & (j>>(2*(k+1)))) == 2)))
                flag = false;
        }
        flags[j] = flag;
    }
}

//0:UP 1:DOWN 2:LEFT 3:RIGHT
int times2(int n,int m){
    int len = 1 << (2*m),len2 = len << (2*m);
    bool flag;

    init_flags(m);

    if (m == 3)
        top[21] = top[27] = top[45] = 1;
    else if (m == 4)
        top[85] = top[91] = top[109] = top[181] = top[187] = 1;
    else if (m == 5)
        top[341] = top[347] = top[365] = top[437] =
        top[443] = top[725] = top[731] = top[749] = 1;

    int right_map=(1<<(2*m))-1;
    for (int i = 1;i < n;++i){
        for (j = 0;j < len2;++j){
            flag = flags[j];
            if (i == n-1) {
                for (int k = 0;k < m && flag;++k){
                    if (((j >> (2*k)) & 3) == 1)
                        flag = false;
                }
            }
            if (flag)
                top2[j & right_map] = (top[j >> (2*m)] + top2[j & right_map]) % MOD;
        }
        for (int i = 0;i < len;++i){
            top[i] = top2[i];
            top2[i] = 0;
        }
    }

    int result = 0;
    for (int i = 0;i < len;++i)
        result = (result + top[i]) % MOD;

    return result;
}

3. 剪枝过的动态规划

注意到主要循环体内每次都需要检测状态是否成立（flags[j]是否为true），换做提前列出所有flags[j]等于true的j，然后枚举这些j，减少循环的次数。
这部分代码大部分和上方相似，这里仅列出剪枝相关代码。 
int true_list[1<<20];

init_flags(m);
int true_len = 0;
for (int i = 0;i < len2;++i)
    if (flags[i])
        true_list[true_len++] = i;

 for (int i = 1;i < n;++i){
        for (int h = 0;h < true_len;++h){
            j = true_list[h];

4. 主函数

int main()
{
    int n,m;
    cin >> n >> m;

    if ((n*m) & 1)
        cout << 0 << endl;
    else
        cout << times2(n,m) << endl;
    return 0;
}

5. 测试代码

包括print全局变量，以及用深搜做真值的寻找错误样例的代码。 

void print_top(int m){
    int len = 1<<(2*m);
    for (int i = 0;i < len;++i)
        if (top[i] > 0)
            cout << i << ':' << top[i] << ' ';
    cout << endl;
}

void print_flags(int m){
    int len = (1<<(4*m));
    cout << "flags: ";
    for (int i = 0;i < len;++i)
        if (flags[i])
            cout << i << ',';
    cout << endl;
}

int compare(){
    int time1,time2;
    for (int i = 2;i < 6;++i){
        for (int j = 3;j < 6;++j) {
            for (int i = 0;i < (1<<10);++i)
                top[i] = top2[i] = 0;
            cout << i << ' ' << j << ':';
            time1 = times(i,j);
            time2 = times2(i,j);
            cout << ' ' << time1 << ' ' << time2 << ' ';
            if (time1 == time2)
                cout << "True" << endl;
            else
                cout << "False" << endl;
        }
    }}

全部代码

#include <iostream>

using namespace std;

#define MOD 1000000007

enum {
    NONE,
    UP,
    DOWN,
    LEFT,
    RIGHT
};

bool incre(int &i,int &j,int n,int m){
    if (i == n-1 && j == m-1)
        return false;
    if (++j == m){
        ++i;
        j = 0;
    }
    return true;
}

void decre(int &i,int &j,int n,int m){
    if (j == 0){
        --i;
        j = m-1;
    }
    else
        --j;
}

int times(int n,int m){
    int status[1000][5] = {0};
    int i = 0,j = 0,result = 0;
    bool forw = true;
    while (i > -1 && j > -1){
        if (status[i][j] == NONE){
            if (j < m-1 && status[i][j+1] == NONE)
                status[i][j] = RIGHT;
            else if (i < n-1 && status[i+1][j] == NONE)
                status[i][j] = DOWN;
        }
        else if (status[i][j] == RIGHT) {
            status[i][j+1] = NONE;
            if (i < n-1 && status[i+1][j] == NONE)
                status[i][j] = DOWN;
            else
                status[i][j] = NONE;
        }

        else if (status[i][j] == DOWN){
            status[i][j] = NONE;
            status[i+1][j] = NONE;
        }

        if (status[i][j] == NONE){
            decre(i,j,n,m);
            forw = false;
        }
        else {
            if (status[i][j] == RIGHT){
                status[i][j+1] = LEFT;
                incre(i,j,n,m);
                forw = true;
            }
            else if (status[i][j] == DOWN){
                status[i+1][j] = UP;
                incre(i,j,n,m);
                forw = true;
            }
            else {
                if (forw){
                    if (!incre(i,j,n,m)){
                        if (++result == 1000000007)
                            result = 0;
                        decre(i,j,n,m);
                        forw = false;
                    }
                }
                else
                    decre(i,j,n,m);
            }
        }
    }
    return result;
}

int top[1<<10];
int top2[1<<10];
bool flags[1<<20];
int true_list[1<<20];

void init_flags(int m){
    int len2 = 1<<(2*2*m),tmp_status;
    bool flag;
    for (int j = 0;j < len2;++j){
        flag = true;
        for (int k = 0;k < m && flag;++k){
            tmp_status = (j >> (2*k)) & 3;
            if (tmp_status == 0 && ((3 & (j>>(2*(k+m)))) != 1))
                flag = false;
            else if (tmp_status == 2 && (k == 0 || ((3 & (j>>(2*(k-1)))) != 3)))
                flag = false;
            else if (tmp_status == 3 && (k == m-1 || ((3 & (j>>(2*(k+1)))) != 2)))
                flag = false;
            else if (tmp_status != 0 && ((3 & (j>>(2*(k+m)))) == 1))
                flag = false;
            else if ((tmp_status != 2 && (k > 0 && ((3 & (j>>(2*(k-1)))) == 3))))
                flag = false;
            else if (tmp_status != 3 && (k < m-1 && ((3 & (j>>(2*(k+1)))) == 2)))
                flag = false;
        }
        flags[j] = flag;
    }
}

void print_top(int m){
    int len = 1<<(2*m);
    for (int i = 0;i < len;++i)
        if (top[i] > 0)
            cout << i << ':' << top[i] << ' ';
    cout << endl;
}

void print_flags(int m){
    int len = (1<<(4*m));
    cout << "flags: ";
    for (int i = 0;i < len;++i)
        if (flags[i])
            cout << i << ',';
    cout << endl;
}

//0:UP 1:DOWN 2:LEFT 3:RIGHT
int times2(int n,int m){
    int len = 1 << (2*m),len2 = len << (2*m);
    bool flag;

    init_flags(m);
    int true_len = 0;
    for (int i = 0;i < len2;++i)
        if (flags[i])
            true_list[true_len++] = i;

    if (m == 3)
        top[21] = top[27] = top[45] = 1;
    else if (m == 4)
        top[85] = top[91] = top[109] = top[181] = top[187] = 1;
    else if (m == 5)
        top[341] = top[347] = top[365] = top[437] =
        top[443] = top[725] = top[731] = top[749] = 1;

    int right_map=(1<<(2*m))-1,j;
    for (int i = 1;i < n;++i){

        for (int h = 0;h < true_len;++h){
            j = true_list[h];
            flag = true;
            if (i == n-1) {
                for (int k = 0;k < m && flag;++k){
                    if (((j >> (2*k)) & 3) == 1)
                        flag = false;
                }
            }
            if (flag)
                top2[j & right_map] = (top[j >> (2*m)] + top2[j & right_map]) % MOD;
        }
        for (int i = 0;i < len;++i){
            top[i] = top2[i];
            top2[i] = 0;
        }
    }

    int result = 0;
    for (int i = 0;i < len;++i)
        result = (result + top[i]) % MOD;

    return result;
}

int main()
{
    int n,m;
    cin >> n >> m;

    if ((n*m) & 1)
        cout << 0 << endl;
    else
        cout << times2(n,m) << endl;

//    int time1,time2;
//    for (int i = 2;i < 6;++i){
//        for (int j = 3;j < 6;++j) {
//            for (int i = 0;i < (1<<10);++i)
//                top[i] = top2[i] = 0;
//            cout << i << ' ' << j << ':';
//            time1 = times(i,j);
//            time2 = times2(i,j);
//            cout << ' ' << time1 << ' ' << time2 << ' ';
//            if (time1 == time2)
//                cout << "True" << endl;
//            else
//                cout << "False" << endl;
//        }
//    }
    return 0;
}






silent56_th
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法练习系列—hiho1048 状态压缩一(铺地砖)
小村长技术blog
03-08 5690
题目地址：http://hihocoder.com/problemset/problem/1048 编程之美的课后题也有一个和整个题目一样的。（P269)  题目 这个题目的题意很容易理解，在一个N*M的格子里，我们现在有两种类型的砖块，1 * 2 和 2 * 1，问一共有多少种方案，可以将整个N*M的空间都填满。 最简单的例子就是下面的了： 编程之美中题目： 某年夏天,位于
动态规划之状态压缩
u014254779的专栏
09-04 835
最近在hihocoder上做的一道题
hihocoder-第九周-状态压缩二
写东西的地方
09-06 934
#include using namespace std; int dp[1001][6][1025]; int getValue( int s, int m) { s >>= (m-1); return s&1; } int main() { int N, M; while( cin >> N >> M){ int col = (1<<(2*
hihoCoder #1048 : 状态压缩·二
albertluf的博客
01-17 240
链接：http://hihocoder.com/problemset/problem/1048 题解：https://blog.csdn.net/my_sunshine26/article/details/74612684 #include&lt;bits/stdc++.h&gt; using namespace std; const int mod=1000000007; int dp[1...
hihocoder 1048 压状DP
我不吃海鲜的博客
03-09 180
hihocoder 1048 做了很久但是2ms压着点过。太慢了。 再来看看能不能缩短点时间。 #include&lt;bits/stdc++.h&gt; #define INF 1e18 #define inf 1e9 #define min(a,b) a&lt;b?a:b #define max(a,b) a&gt;b?a:b #define lson l,m,rt&lt;&lt;1 ...
ACM解题总结——HihoCoder1048
<code> I am a coder </code>
05-06 1558
(p.s：第一次做状态压缩dp的题目，真是把俺折腾到死。。。。) 题目来源：    HihoCoder 1048 题目要求：    小Hi和小Ho领到了一个大小为N*M的长方形盘子，他们可以用这个盒子来装一些大小为2*1的蛋糕。但是根据要求，他们一定要将这个盘子装的满满的，一点缝隙也不能留下来，才能够将这些蛋糕带走。     于是他们提出了一个问题——他们有多少种方案来装
hihocoder week1 answer
11-17
微软hiho coder平台第一周题目，最长回文子串。
hihocoder:hihocoder上的系列题解(http
05-18
【压缩包子文件的文件名称列表】"hihocoder-master" 告诉我们这是一个Git仓库的主分支，通常包含了一个项目的所有源代码文件和相关的配置文件。"master"分支是Git的基本分支，意味着这里存放的是项目的主要版本。 ...
hihocoder和leetcode-leetcode:leetcode
07-06
hihocoder和leetcode leetcode 目录名 功能 Array 数组 Backtracking 回溯 Bit_Manipulation 位操作 Design 数据结构设计 Divide_and_Conquer 分而治之 DP 动态规划 Hash_Table 哈希表 List 链表 Math 数学 Stack 栈...
hihocoder和leetcode-JInterview:J访谈
07-06
hihocoder和leetcode JInterview 一套完整的Java学习路径帮助自己拿到大厂Offier 目录 在线练习 在线面试编程 操作系统和团队工具 基础深入 框架源码 微服务架构 高并发分布式
leetcode2-algorithm:这个repo是记录我们所有成员在各个题目网站（leetcode、hihocoder等）做的题目
06-29
这个repo是记录我们所有成员在各个题目网站（leetcode、hihocoder等）做的题目； repo的内容仍需要完善，做题网站也不仅仅限制于已有的这些题目来源。 鉴于这是python社区，所以目前主要支持python3代码（py2不再...
hihoCoder1048 : 状态压缩·二
ACoder
05-06 487
插头DP
hihoCoder#1048 状态压缩·二
dicui3114的博客
03-31 95
原题地址 位运算的状态压缩太操蛋了，很容易出错。。。又是数组没开够导致诡异现象（明明某个值是1，莫名其妙就变成0了），害我debug一整天！fuck 代码： 1 #include <iostream> 2 #include <cstring> 3 4 using namespace std; 5 6 #define ...
hihocoder1048 : 状态压缩·二
a774468183的专栏
09-13 93
题目链接:http://hihocoder.com/problemset/problem/1048?sid=1171317 　　1.思路 　　　　状压DP经典题目,对于横着放的矩形,我们将两个格子都标记为1;对于竖着放的矩形,我们将(i-1,j) 标记为0, 将(i, j) 标记为1; 　　2.代码 /***************************...
[hihocoder1324]希尔伯特曲线
silent56_th的博客
08-15 1158
这是hiho一下 第163周的题目。题目描述时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 希尔伯特曲线是以下一系列分形曲线 Hn 的极限。我们可以把 Hn 看作一条覆盖 2n × 2n 方格矩阵的曲线，曲线上一共有 2n × 2n 个顶点(包括左下角起点和右下角终点)，恰好覆盖每个方格一次。Hn(n > 1)可以通过如下方法构造： 将 Hn-1 顺时针旋转90
[hihocoder1323]回文字符串
silent56_th的博客
08-10 813
这是一道hiho一下 第162周的笔试题。题目描述时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 给定一个字符串 S ，最少需要几次增删改操作可以把 S 变成一个回文字符串？一次操作可以在任意位置插入一个字符，或者删除任意一个字符，或者把任意一个字符修改成任意其他字符。输入 字符串 S。S 的长度不超过100, 只包含’A’-‘Z’。输出 最少的修改次数。样
[hihocoder1546]集合计数
silent56_th的博客
08-11 756
题目描述时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 给定一个包含N个整数的集合S={A1, A2, … AN}，以及一个给定的整数K，请计算有多少个S的子集满足其中的最大值与最小值的和小于等于K。例如对于S={4, 2, 5, 8}以及K=7,满足的条件的子集有以下4个:{2}, {2, 4}, {2, 5}, {2, 4, 5}。输入 第一行包含两个整数
[hihocoder1318]非法二进制数
silent56_th的博客
01-04 745
问题描述时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 如果一个二进制数包含连续的两个1，我们就称这个二进制数是非法的。小Hi想知道在所有 n 位二进制数（一共有2n个）中，非法二进制数有多少个。例如对于 n = 3,有 011, 110, 111 三个非法二进制数。由于结果可能很大，你只需要输出模109+7的余数。输入 一个整数 n (1 ≤ n ≤ 100
[hihocoder1039]字符消除
silent56_th的博客
12-02 684
问题简介 具体参照hihocoder网站。 实现思路 因为字符串长度最大为100，只有ABC三个字符，所以只有300种情况，每种情况最差处理是O(100^2)。所以即便最差情况也只有3e6的计算次数，不足10ms。 因此只需要实现穷举算法即可，先插入字符，然后判断会消除多少字符。 代码 1. 消除字符的函数 输入字符串，返回消除字符的数目，同时字符串改变为消除之后的字符串。例如str
算法题精要：面试必备知识梳理
"这是一份综合了多种算法题目的总结，包括来自《剑指offer》、leetcode、lintcode、hihocoder和《王道程序员求职宝典》等平台的题目，旨在帮助准备面试的人员提升算法能力和技术素养。涵盖了数组、字符串、链表、树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值