[HDU 5731] Solid Dominoes Tilings （轮廓线DP+容斥定理）

最新推荐文章于 2019-02-17 19:26:49 发布
最新推荐文章于 2019-02-17 19:26:49 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 计数 技巧 轮廓线DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012015746/article/details/51971977
版权
技巧 同时被 3 个专栏收录
56 篇文章 0 订阅
订阅专栏
计数
18 篇文章 0 订阅
订阅专栏
轮廓线DP
1 篇文章 0 订阅
订阅专栏

HDU - 5731

多米诺骨牌的矩形完全覆盖，
要求统计没有横切割线和竖切割线的方案数

第一部分就是轮廓线 DP 的入门裸题
预处理出任意矩形大小的方案数 RES[i][j]
不过我怀疑这部分不提前打表的过不了

第二部分是一个容斥
先对列容斥，用状压的方式枚举出所有列的分割情况
然后计算，当前列分割情况下，行没有分割的方案数 dp[n]
然后再用容斥，奇加偶减即能得出答案

而 dp[n] 的求法为，设当前分割下，宽度为 x的无限制覆盖为 cnt[x]
cnt[x]=RES[x][bsiz1]∗RES[x][bsiz2]∗...∗RES[x][bsizt]
其中 bsiz1...bsizt 为列分割线分割出的每一块的横向大小
dp[i]=cnt[i]−∑i−1j=0dp[j]∗cnt[i−j]
其中 cnt[i] 为宽度为 i的任意覆盖，
减去每一个前 j 个无行分割线，后 i−j个有行分割线的方案
减去这些互斥的非法方案，剩下的即为宽度为 i <script id="MathJax-Element-337" type="math/tex">i</script>的无行分割线的合法覆盖

#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <map>
#include <set>
#include <queue>
using namespace std;
typedef pair<int,int> Pii;
typedef long long LL;
typedef unsigned long long ULL;
typedef double DBL;
typedef long double LDBL;
#define MST(a,b) memset(a,b,sizeof(a))
#define CLR(a) MST(a,0)
#define Sqr(a) ((a)*(a))

const int MOD=1e9+7;
LL RES[20][20];
LL dp[2][1<<16];

void init(int,int);
void VAL();
LL solve(int,int);

int main()
{
    #ifdef LOCAL
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    #endif

//  for(int i=1; i<=16; i++) for(int j=1; j<=16; j++) init(i,j);
//  for(int i=1; i<=16; i++) for(int j=1; j<=16; j++) printf("RES[%d][%d] = %lld;\n", i, j, RES[i][j]);
    VAL();

    int N,M;
    while(~scanf("%d%d", &N, &M))
    {
        printf("%lld\n", solve(N,M));
    }
    return 0;
}

LL solve(int n, int m)
{
    LL res=0;
    int bcnt, bsiz, block[25];
    int dp[25];
    for(int cut=0; cut<(1<<m-1); cut++)
    {
        bcnt=0, bsiz=0;
        for(int i=0; i<m-1; i++)
        {
            if(cut&(1<<i))
            {
                block[bcnt++] = bsiz+1;
                bsiz=0;
            }
            else bsiz++;
        }
        block[bcnt++] = bsiz+1;
        for(int i=1; i<=n; i++)
        {
            for(int j=0; j<i; j++)
            {
                LL cnt=1;
                for(int k=0; k<bcnt; k++) cnt = (cnt * RES[i-j][block[k]]) % MOD;
                if(!j) dp[i] = cnt;
                else dp[i] = (dp[i]-cnt*dp[j])%MOD;
            }
        }
        if(bcnt&1) res = (res+dp[n])%MOD;
        else res = (res-dp[n])%MOD;
    }
    return (res+MOD)%MOD;
}

void init(int n, int m)
{
    int fmask=(1<<m)-1;
    CLR(dp);
    dp[0][fmask]=1;
    int cur=0, las=1;
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            las=cur, cur^=1;
            CLR(dp[cur]);
            for(int ms=0; ms<1<<m; ms++) if(dp[las][ms])
            {
                if(!(ms&(1<<m-1))) 
                {
                    dp[cur][( (ms<<1)|1 )&fmask] += dp[las][ms];
                    dp[cur][( (ms<<1)|1 )&fmask] %= MOD;
                }
                else
                {
                    dp[cur][ (ms<<1)&fmask ] += dp[las][ms];
                    dp[cur][ (ms<<1)&fmask ] %= MOD;
                    if(j && !(ms&1))
                    {
                        dp[cur][ ((ms<<1)|3)&fmask ] += dp[las][ms];
                        dp[cur][ ((ms<<1)|3)&fmask ] %= MOD;
                    }
                }
            }
        }
    }
    RES[n][m] = dp[cur][fmask];
}

void VAL()
{
    RES[1][1] = 0;
    RES[1][2] = 1;
    RES[1][3] = 0;
    RES[1][4] = 1;
    RES[1][5] = 0;
    RES[1][6] = 1;
    RES[1][7] = 0;
    RES[1][8] = 1;
    RES[1][9] = 0;
    RES[1][10] = 1;
    RES[1][11] = 0;
    RES[1][12] = 1;
    RES[1][13] = 0;
    RES[1][14] = 1;
    RES[1][15] = 0;
    RES[1][16] = 1;
    RES[2][1] = 1;
    RES[2][2] = 2;
    RES[2][3] = 3;
    RES[2][4] = 5;
    RES[2][5] = 8;
    RES[2][6] = 13;
    RES[2][7] = 21;
    RES[2][8] = 34;
    RES[2][9] = 55;
    RES[2][10] = 89;
    RES[2][11] = 144;
    RES[2][12] = 233;
    RES[2][13] = 377;
    RES[2][14] = 610;
    RES[2][15] = 987;
    RES[2][16] = 1597;
    RES[3][1] = 0;
    RES[3][2] = 3;
    RES[3][3] = 0;
    RES[3][4] = 11;
    RES[3][5] = 0;
    RES[3][6] = 41;
    RES[3][7] = 0;
    RES[3][8] = 153;
    RES[3][9] = 0;
    RES[3][10] = 571;
    RES[3][11] = 0;
    RES[3][12] = 2131;
    RES[3][13] = 0;
    RES[3][14] = 7953;
    RES[3][15] = 0;
    RES[3][16] = 29681;
    RES[4][1] = 1;
    RES[4][2] = 5;
    RES[4][3] = 11;
    RES[4][4] = 36;
    RES[4][5] = 95;
    RES[4][6] = 281;
    RES[4][7] = 781;
    RES[4][8] = 2245;
    RES[4][9] = 6336;
    RES[4][10] = 18061;
    RES[4][11] = 51205;
    RES[4][12] = 145601;
    RES[4][13] = 413351;
    RES[4][14] = 1174500;
    RES[4][15] = 3335651;
    RES[4][16] = 9475901;
    RES[5][1] = 0;
    RES[5][2] = 8;
    RES[5][3] = 0;
    RES[5][4] = 95;
    RES[5][5] = 0;
    RES[5][6] = 1183;
    RES[5][7] = 0;
    RES[5][8] = 14824;
    RES[5][9] = 0;
    RES[5][10] = 185921;
    RES[5][11] = 0;
    RES[5][12] = 2332097;
    RES[5][13] = 0;
    RES[5][14] = 29253160;
    RES[5][15] = 0;
    RES[5][16] = 366944287;
    RES[6][1] = 1;
    RES[6][2] = 13;
    RES[6][3] = 41;
    RES[6][4] = 281;
    RES[6][5] = 1183;
    RES[6][6] = 6728;
    RES[6][7] = 31529;
    RES[6][8] = 167089;
    RES[6][9] = 817991;
    RES[6][10] = 4213133;
    RES[6][11] = 21001799;
    RES[6][12] = 106912793;
    RES[6][13] = 536948224;
    RES[6][14] = 720246619;
    RES[6][15] = 704300462;
    RES[6][16] = 289288426;
    RES[7][1] = 0;
    RES[7][2] = 21;
    RES[7][3] = 0;
    RES[7][4] = 781;
    RES[7][5] = 0;
    RES[7][6] = 31529;
    RES[7][7] = 0;
    RES[7][8] = 1292697;
    RES[7][9] = 0;
    RES[7][10] = 53175517;
    RES[7][11] = 0;
    RES[7][12] = 188978103;
    RES[7][13] = 0;
    RES[7][14] = 124166811;
    RES[7][15] = 0;
    RES[7][16] = 708175999;
    RES[8][1] = 1;
    RES[8][2] = 34;
    RES[8][3] = 153;
    RES[8][4] = 2245;
    RES[8][5] = 14824;
    RES[8][6] = 167089;
    RES[8][7] = 1292697;
    RES[8][8] = 12988816;
    RES[8][9] = 108435745;
    RES[8][10] = 31151234;
    RES[8][11] = 940739768;
    RES[8][12] = 741005255;
    RES[8][13] = 164248716;
    RES[8][14] = 498190405;
    RES[8][15] = 200052235;
    RES[8][16] = 282756494;
    RES[9][1] = 0;
    RES[9][2] = 55;
    RES[9][3] = 0;
    RES[9][4] = 6336;
    RES[9][5] = 0;
    RES[9][6] = 817991;
    RES[9][7] = 0;
    RES[9][8] = 108435745;
    RES[9][9] = 0;
    RES[9][10] = 479521663;
    RES[9][11] = 0;
    RES[9][12] = 528655152;
    RES[9][13] = 0;
    RES[9][14] = 764896039;
    RES[9][15] = 0;
    RES[9][16] = 416579196;
    RES[10][1] = 1;
    RES[10][2] = 89;
    RES[10][3] = 571;
    RES[10][4] = 18061;
    RES[10][5] = 185921;
    RES[10][6] = 4213133;
    RES[10][7] = 53175517;
    RES[10][8] = 31151234;
    RES[10][9] = 479521663;
    RES[10][10] = 584044562;
    RES[10][11] = 472546535;
    RES[10][12] = 732130620;
    RES[10][13] = 186229290;
    RES[10][14] = 274787842;
    RES[10][15] = 732073997;
    RES[10][16] = 320338127;
    RES[11][1] = 0;
    RES[11][2] = 144;
    RES[11][3] = 0;
    RES[11][4] = 51205;
    RES[11][5] = 0;
    RES[11][6] = 21001799;
    RES[11][7] = 0;
    RES[11][8] = 940739768;
    RES[11][9] = 0;
    RES[11][10] = 472546535;
    RES[11][11] = 0;
    RES[11][12] = 177126748;
    RES[11][13] = 0;
    RES[11][14] = 513673802;
    RES[11][15] = 0;
    RES[11][16] = 881924366;
    RES[12][1] = 1;
    RES[12][2] = 233;
    RES[12][3] = 2131;
    RES[12][4] = 145601;
    RES[12][5] = 2332097;
    RES[12][6] = 106912793;
    RES[12][7] = 188978103;
    RES[12][8] = 741005255;
    RES[12][9] = 528655152;
    RES[12][10] = 732130620;
    RES[12][11] = 177126748;
    RES[12][12] = 150536661;
    RES[12][13] = 389322891;
    RES[12][14] = 371114062;
    RES[12][15] = 65334618;
    RES[12][16] = 119004311;
    RES[13][1] = 0;
    RES[13][2] = 377;
    RES[13][3] = 0;
    RES[13][4] = 413351;
    RES[13][5] = 0;
    RES[13][6] = 536948224;
    RES[13][7] = 0;
    RES[13][8] = 164248716;
    RES[13][9] = 0;
    RES[13][10] = 186229290;
    RES[13][11] = 0;
    RES[13][12] = 389322891;
    RES[13][13] = 0;
    RES[13][14] = 351258337;
    RES[13][15] = 0;
    RES[13][16] = 144590622;
    RES[14][1] = 1;
    RES[14][2] = 610;
    RES[14][3] = 7953;
    RES[14][4] = 1174500;
    RES[14][5] = 29253160;
    RES[14][6] = 720246619;
    RES[14][7] = 124166811;
    RES[14][8] = 498190405;
    RES[14][9] = 764896039;
    RES[14][10] = 274787842;
    RES[14][11] = 513673802;
    RES[14][12] = 371114062;
    RES[14][13] = 351258337;
    RES[14][14] = 722065660;
    RES[14][15] = 236847118;
    RES[14][16] = 451896972;
    RES[15][1] = 0;
    RES[15][2] = 987;
    RES[15][3] = 0;
    RES[15][4] = 3335651;
    RES[15][5] = 0;
    RES[15][6] = 704300462;
    RES[15][7] = 0;
    RES[15][8] = 200052235;
    RES[15][9] = 0;
    RES[15][10] = 732073997;
    RES[15][11] = 0;
    RES[15][12] = 65334618;
    RES[15][13] = 0;
    RES[15][14] = 236847118;
    RES[15][15] = 0;
    RES[15][16] = 974417347;
    RES[16][1] = 1;
    RES[16][2] = 1597;
    RES[16][3] = 29681;
    RES[16][4] = 9475901;
    RES[16][5] = 366944287;
    RES[16][6] = 289288426;
    RES[16][7] = 708175999;
    RES[16][8] = 282756494;
    RES[16][9] = 416579196;
    RES[16][10] = 320338127;
    RES[16][11] = 881924366;
    RES[16][12] = 119004311;
    RES[16][13] = 144590622;
    RES[16][14] = 451896972;
    RES[16][15] = 974417347;
    RES[16][16] = 378503901;
}
mis_deer
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【容斥原理+状态压缩】zjoi2009 多米诺骨牌
Evil.livE
04-19 3473
<br /><br />转送门：zjoi2009 多米诺骨牌<br /> <br /> <br />彻彻底底的被这道题虐了，想了一个月没想出来，最后和宇宙大总统一起强肯了2个小时标程算是看懂了。。<br />首先抛开这道题的那个奇怪的限制（没行列没有骨牌跨过），一个赤裸裸的骨牌覆盖我都不不知道怎么做啊！！<br />先看下赤裸裸的骨牌覆盖怎么做：<br />一般人的反映就会想到状态压缩DP，没错<br />状态为F【I，J】表示第i行的状态为J的方案数>>空间复杂度O（N*2^N），转移O（2^N），写的好
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
Hdu 5731 Solid Dominoes Tilings
lambda QAQ
07-28 567
问n×m n \times m的格子铺上1×21 \times 2的骨牌使得对于任何一条行/列分割线都会跨越骨牌定义anyn,many_{n,m} 为用骨牌铺满n×m n \times m的格子在不考虑题目条件的方案数然后容斥容斥的时候我们列举列分割线，求在当前枚举的列分割线存在的情况下没有行分割线的方案数，然后按照枚举的分割线的方案数做一个奇加偶减的容斥就好具体的，我们假设分割线分隔出来的块共p
hdu 5731 Solid Dominoes Tilings 插头dp+容斥原理
便纵有千种风情
07-23 1363
题意：给出一个n*m大小的棋盘，需要你用1*2的砖铺满它，砖不可重叠，并且要求棋盘上没有行分割线或列分割线。 输出方法种数。需要取模。
HDU 5731 Solid Dominoes Tilings（轮廓线DP+容斥）
ZSQ
07-25 826
Description 求n*m区域用2*1和1*2的骨牌铺满且没有横竖割线的方案数 Input 多组用例，每组用例占一行包括两个整数n和m，以文件尾结束输入(1<=m,n<=16) Output 对于每组用例，输出合法方案数，结果模1e9+7 Sample Input 2 2 5 6 8 7 Sample Output 0 6 13514 Solution 首先用轮廓
hdu5731
weixin_34122604的博客
02-19 103
先求出不考虑分割线的n*m棋盘的覆盖方案数记为f[n][m] 然后枚举列分割线的状态（状压），计算此时不存在行分割线的方案数 求出这个我们就可以用容斥原理算出答案了 怎么算在列分割线确定的情况下，不存在行分割线的方案数呢？ 记s[i]=f[i][a1]*f[i][a2]*...表示在有i行不考虑行分割线且列分割线分成a1,a2...ak块的方案数 则到第i行不存在行分割线的方案数g[i]...
hdu 1695 GCD（欧拉函数+容斥原理）.docx
10-29
"hdu 1695 GCD（欧拉函数+容斥原理）" 题目大意是：给定 a, b, c, d, k，找到一队 x, y，满足 g(x, y) = k，且 x ∈ [1, b], y ∈ [1, d]，问有多少对符合要求的 (x, y)。 思路是：gcd(x, y) == k 解释 x, y 都能...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
动态规划DP题解 POJ HDU部分动态规划DP题解
HDU刷题地图+精选详细笔记
10-26
本人准备2020年保研机试时刷的题目（虽然最后机试取消了，...来自某中流985，在HDU和vjudge平台上大概刷了400道。本文件地图（excel表格）包含了绝大部分我刷过的题目，笔记中具有思路、代码、总结和心得。 大佬勿入！
HDU DP题解
02-07
HDU上DP大集合，里面包括题，题解，代码，对DP入门者很实用，对DP老手也是有很大的提高
hdu1964 Pipes（轮廓线dp）
苟为蒟蒻又何妨
01-23 192
传送门 题意简述：给一个没有障碍的网格图，任意两个格子连通需要花费一定代价，现在求一条覆盖所有格子的哈密顿回路的总权值的最小值。 思路： 跟这道题一毛一样，除了把求和变成求最小值以外。 代码： #include&lt;bits/stdc++.h&gt; #define ri register int using namespace std; inline int read(){ int ans...
hdu5731（状压+容斥）
nucshiyilang的博客
03-09 313
题意：多米诺骨牌的矩形完全覆盖，            要求统计没有横切割线和竖切割线的方案数 题解 第一部分就是轮廓线DP的入门裸题 预处理出任意矩形大小的方案数 RES[i][j] 不过我怀疑这部分不提前打表的过不了 第二部分是一个容斥 先对列容斥，用状压的方式枚举出所有列的分割情况 然后计算，当前列分割情况下，行没有分割的方案数 dp[n] 然后再
hdu5731Solid Dominoes Tilings
Fsss
09-09 365
链接：http://acm.split.hdu.edu.cn/showproblem.php?pid=5731 题意：给定n*m的矩阵，求用骨牌覆盖且稳定的方案数。稳定的定义是没有一行或一列的缝隙是直接分割整个矩阵的。 分析：预处理出所有矩阵为i*j的覆盖方案，然后按列容斥按行递推。预处理可以看骨牌覆盖，然后按列容斥很简单，按行递推就是代码里的b[j]-=b[k]*a[j-k]啦。详见代码。
manacher算法入门HDU5731
nucshiyilang的博客
06-05 242
马拉车算法，线性求出回文串。。具体就不讲了，可以参考博题目链接客 说下这个题的想法，，，首先求出每个数字的回文串长度（包括-1的）。然后枚举每一个数，在他的回文串长度内，继续枚举右区间，看右区间有没有回文串长度和左区间一样长的。然后求个最大值就好了。。。就是说 在2 3 4 4 3 2 2 3 4 中找到了最长的回文串 2 3 4 4 3 2.然后枚举4 3 2看他们的回文串长度有没有回文串长度
HDU 5731 2016多校Contest 1 F题【轮廓线DP+容斥原理】
ACMer不要报考高校代码为13627的移通学院！
08-04 333
首先轮廓线DP部分： 见博客上一题。 首先一个简单的递推，f[i]表示i行元素，全部没有被横着切割的方案总数,s[i]为i行元素的总方案数。 f[i] = s[i] = sum(f[j] * s[i-j]) 如果先求出所有竖着切的方案，再求横着切的方案。 利用竖着切的结果，求横着切的的时候会出现一个情况…… 形如图所示的情况，会出现问题。
[HDU 5731]Solid Dominoes Tilings：状压DP+容斥原理
SmallSXJ的博客
05-03 463
点击这里查看原题这题是POJ 2411的升级版。dp[i][j]表示长为i宽为j的方案数，打个表预处理一下。然后枚举列的切割方案，因为一共有m-1条竖线，因此有2^(m-1)种情况。cnt[i]表示按当前的列分割方案，宽为i的矩形的方案数，f[i]表示在当前列分割情况下，前i行的情况数，f[i]=cnt[i]-sigma{f[j]*cnt[i-j]}(0/* User:Small Language:
hdu1992(轮廓线dp铺砖问题)
qq_39861441的博客
02-17 421
解题思路： 关于铺砖问题https://blog.csdn.net/u013480600/article/details/19499899讲的很清楚 其实就是从左上角开始向下右下方向循环下去。dp[cur][k]:表示当前处理点(i,j)左上方的状态值，dp[1-cur][k]表示的是包括（i，j）点的新一轮生成状态值。 动态规划公式就像代码中注释的一样。 #include&lt;cst...
【HDU5731 2016 Multi-University Training Contest 1I】【轮廓线DP+容斥】Solid Dominoes Tilings nm棋盘1x2多边形填充稳定方案
snowy_smile的博客
07-25 1633
Solid Dominoes Tilings Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 164    Accepted Submission(s): 100 Problem Description Dominoes
[HDU 5180]chess 组合+轮廓线状压dp
liu_cheng_ao的博客
02-28 606
题面：http://acm.hdu.edu.cn/showproblem.php?pid=5180 体会到了轮廓线的边界情况的可怕。。。 题意：n*n国际象棋棋盘上放k个车和任意数量的王，要求车不能吃车，车不能吃王，王不能吃王，王可以吃车，问方案数模1e9+7 1 题解： 法1：暴力状压每列4种状态：没有棋子，最后一格有个王，前面有个王，有个车。状态O(n*4^n)，转移O(4^n)，时
hdu 2829 lawrence 斜率优化dp
最新发布
06-28
hdu 2829 Lawrence 斜率优化dp 这道题是一道经典的斜率优化dp题目，需要用到单调队列的思想。 题目大意是给定一个序列a，求出一个序列b，使得b[i]表示a[1]~a[i]中的最小值，且满足b[i] = min{b[j] + (i-j)*k}，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值