LOJ6301：「CodePlus 2018 3 月赛」白金元首与莫斯科 （类插头DP）

最新推荐文章于 2019-12-25 10:45:58 发布
最新推荐文章于 2019-12-25 10:45:58 发布
阅读量422 收藏 2
点赞数 1
分类专栏： DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KsCla/article/details/79462642
版权
本文介绍了一种在特定条件下优化状态压缩动态规划（状压DP）的方法，通过单格子转移而非按行转移来减少时间开销。文章分享了一个具体的算法实现案例，并详细解释了如何通过位运算和分类讨论来实现O(nm2^m)的时间复杂度。
摘要由CSDN通过智能技术生成

题目传送门：https://loj.ac/problem/6301

题目分析：比赛的时候乱写了个 O(n2m3m) O ( n 2 m 3 m ) 的状压DP，结果只拿了14pts。当时我还在想怎么才能拿第一个点的那10pts，要不要再写一个另外的算法。后来发现由于 n<m n < m ，只需要交换 n,m n , m ，稍微处理一下就好了QAQ。赛后30min发现自己还能写 O(n3m) O ( n 3 m ) 的方法，于是补了一发，然而卡不过 n=15 n = 15 的点……

其实我之前写的状压DP都是按行转移的。插头DP可以单格子转移但因为太难写我就弃了，这题比较像状压才去写了一下（依然比较难写）。这题要按行转移就必须枚举子集，时间开销太高。加上题目中只令一个格子变为障碍物这样的特殊条件，还是一个一个格子转移更优。如果在单格子(i,j)处转移的话，状压的就是(i,j)左上方的一条轮廓线，这条轮廓线同样只需要用0/1记录有没有下插头即可。而(i,j)处有两种插头（左和下），所以要加多一位，总状态数变为 2m+1 2 m + 1 。转移的时候通过分类讨论和一些位运算，即可做到 O(nm2m) O ( n m 2 m ) 。

按地图正反都做一遍这个DP，然后枚举答案，将两边的状态对应起来，同样是这个时间复杂度。注意加一些底层优化。总之本机测试不开O2优化最慢的点要跑3.8s，交上LOJ开了O2后只要900多msOwO。

代码奇长系列

CODE：

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<stdio.h>
#include<algorithm>
using namespace std;

const int maxn=22;
const int maxs=(1<<18)+100;
const int M=1000000007;

int f[maxn][maxn][maxs];
int g[maxn][maxn][maxs];

int map[maxn][maxn];
int n,m;

int Get(int x)
{
    return (1<<(x-1));
}

int Mod(int x)
{
    if (x>=M) return x-M;
    return x;
}

int main()
{
    freopen("C.in","r",stdin);
    freopen("C.out","w",stdout);

    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
        for (int j=1; j<=m; j++) scanf("%d",&map[i][j]);
    int ms=(1<<(m+1));

    f[1][1][0]=1;
    if (!map[1][1]) f[1][1][1]=1,f[1][1][2]=1;
    for (int i=1; i<=n; i++)
        for (int j=1; j<=m; j++) if ( i<n || j<m )
            for (int s=0; s<ms; s++) if (f[i][j][s])
            {
                int x=(s&Get(j+1));
                int y=(s&Get(j+2));
                if ( (x&&y) || ( (x||y) && map[i][j+1] ) ) continue;

                if (j<m)
                    if (map[i][j+1])
                    {
                        int &v=f[i][j+1][s];
                        v=Mod(v+f[i][j][s]);
                    }
                    else
                    {
                        if (x)
                        {
                            int &v=f[i][j+1][s^Get(j+1)];
                            v=Mod(v+f[i][j][s]);
                        }
                        if (y)
                        {
                            int &v=f[i][j+1][s^Get(j+2)];
                            v=Mod(v+f[i][j][s]);
                        }
                        if ( !x && !y )
                        {
                            int num=f[i][j][s];
                            int &p=f[i][j+1][s];
                            p=Mod(p+num);
                            int &q=f[i][j+1][s|Get(j+1)];
                            q=Mod(q+num);
                            int &r=f[i][j+1][s|Get(j+2)];
                            r=Mod(r+num);
                        }
                    }
                else
                {
                    if (x) continue;
                    y=(s&1);
                    if ( y && map[i+1][1] ) continue;

                    if (map[i+1][1])
                    {
                        int &v=f[i+1][1][s<<1];
                        v=Mod(v+f[i][j][s]);
                    }
                    else
                        if (y)
                        {
                            int &v=f[i+1][1][(s^1)<<1];
                            v=Mod(v+f[i][j][s]);
                        }
                        else
                        {
                            int num=f[i][j][s],t=(s<<1);
                            int &p=f[i+1][1][t];
                            p=Mod(p+num);
                            int &q=f[i+1][1][t|1];
                            q=Mod(q+num);
                            int &r=f[i+1][1][t|2];
                            r=Mod(r+num);
                        }
                }
            }

    //printf("%d\n",f[n][m][0]);

    g[n][m][0]=1;
    if (!map[n][m]) g[n][m][Get(m+1)]=1,g[n][m][Get(m)]=1;
    for (int i=n; i>=1; i--)
        for (int j=m; j>=1; j--) if ( i>1 || j>1 )
            for (int s=0; s<ms; s++) if (g[i][j][s])
            {
                if (j>1)
                {
                    int x=(s&Get(j));
                    int y=(s&Get(j-1));
                    if ( (x&&y) || ( (x||y) && map[i][j-1] ) ) continue;

                    if (map[i][j-1])
                    {
                        int &v=g[i][j-1][s];
                        v=Mod(v+g[i][j][s]);
                    }
                    else
                    {
                        if (x)
                        {
                            int &v=g[i][j-1][s^Get(j)];
                            v=Mod(v+g[i][j][s]);
                        }
                        if (y)
                        {
                            int &v=g[i][j-1][s^Get(j-1)];
                            v=Mod(v+g[i][j][s]);
                        }
                        if ( !x && !y )
                        {
                            int num=g[i][j][s];
                            int &p=g[i][j-1][s];
                            p=Mod(p+num);
                            int &q=g[i][j-1][s|Get(j-1)];
                            q=Mod(q+num);
                            int &r=g[i][j-1][s|Get(j)];
                            r=Mod(r+num);
                        }
                    }
                }
                else
                {
                    if (s&1) continue;
                    int y=(s&Get(m+1));
                    if ( y && map[i-1][m] ) continue;

                    if (map[i-1][m])
                    {
                        int &v=g[i-1][m][s>>1];
                        v=Mod(v+g[i][j][s]);
                    }
                    else
                        if (y)
                        {
                            int &v=g[i-1][m][(s^Get(m+1))>>1];
                            v=Mod(v+g[i][j][s]);
                        }
                        else
                        {
                            int num=g[i][j][s],t=(s>>1);
                            int &p=g[i-1][m][t];
                            p=Mod(p+num);
                            int &q=g[i-1][m][t|Get(m)];
                            q=Mod(q+num);
                            int &r=g[i-1][m][t|Get(m+1)];
                            r=Mod(r+num);
                        }
                }
            }

    //printf("%d\n",g[1][1][0]);

    f[0][m][0]=1;
    for (int i=0; i<n; i++)
        for (int s=0; s<ms; s++) if (!(s&Get(m+1)))
            f[i+1][0][s<<1]=f[i][m][s];
    g[n+1][1][0]=1;
    for (int i=n+1; i>1; i--)
        for (int s=0; s<ms; s++) if (!(s&1))
            g[i-1][m+1][s>>1]=g[i][1][s];

    for (int i=1; i<=n; i++)
    {
        for (int j=1; j<=m; j++)
            if (map[i][j]) printf("0 ");
            else
            {
                int ans=0;
                for (int s=0; s<ms; s++)
                    if ( !(s&Get(j)) && !(s&Get(j+1)) )
                        ans=Mod(ans+ (long long)f[i][j-1][s]*g[i][j+1][s]%M );
                printf("%d ",ans);
            }
        printf("\n");
    }

    return 0;
}
KsCla
关注
专栏目录
【BZOJ5205】【LOJ6301】「CodePlus 2018 3 月赛」白金元首与莫斯科
cz_xuyixuan的博客
03-07 748
【题目链接】点击打开链接【思路要点】考虑从前向后、从后向前各做一次状压DP，在询问时合并信息。注意到问题等价于用\(1*2\)和\(1*1\)的棋子填满棋盘，我们可以把\(1*1\)的棋子一并在状压DP时考虑进去。合并答案时只需要枚举\(2^N\)个状态，将满足条件的DP值相乘，累加入答案即可。举例来说，在下图中，合法的状态应当满足在标号为4处已经填上棋子，在标号和为3的绿色和蓝色方格，是否填上棋...
LOJ刷题记录：2018-2020
OIljt12138的博客
08-27 771
LOJ刷题记录：2018-2020
BZOJ5205 [CodePlus 2018 3 月赛]白金元首与莫斯科
weixin_34301132的博客
11-30 148
传送门 emm在雅礼集训的时候听到的一道题 上来就觉得是插头dp 最后果然是轮廓线状压233 我们简化一下题意。 有一个n*m的网格，每个格子是空地或障碍物，询问把每一个空地看成障碍物的情况下，用1*2的骨牌覆盖（可以留有空地）的方案数 对1e9+7取模 bzoj和洛咕题面都挂了233 我们发现留有空地就很烦，所以我们可以把空地看成1*1的骨牌，这样的话我们统计的方案数就是用1*1的骨牌和1...
CodePlus 2018 3 月赛 白金元首与莫斯科 插头DP
rgnoH的博客
03-10 950
题面：https://loj.ac/problem/6301 一眼就看出是一道插头DP题，只记录插头的有无。然而直接枚举每个格子当成障碍来算的话，时间复杂度是O(n32n)O(n32n)O(n^32^n)，这里设m,nm,nm,n同阶。这样做只有24分。 这道题空间开得很大，足足有1G。这启发我们可以记录所有状态。 于是想到，先假设只有那些已经确定的障碍格子，从左上角开始做一次插头DP，...
「CodePlus 2018 3 月赛」白金元首与莫斯科
a2850363633的博客
04-13 155
$n \leq 17,m \leq 17$，$n*m$的01矩形，对每一个0问：当他单独变成1之后，在其他0处放多米诺牌（不一定放满，可以不放）的方案数。膜$1e9+7$。 直接$dp$是$n^42^n$，很难受。这种整体挖一块的东西可以用拼接法，就是用那一块前的$dp$值和那一块后的$dp$值计算答案。 $f(i,j,k)$--从$(1,1)$到$(i,j)$，在$(i,j)$前面...
LOJ #6297. 「CodePlus 2018 3 月赛」投票统计 （ STL
Yishui_lovely
03-04 288
投票统计 题目描述 为了总结过去一段时间的命题工作，王队长组织了“我最喜欢的题目”评选活动，并邀请各位选手给题目进行投票。 具体来说，每道题目有一个正整数作为它的编号，一共有 nnn 名选手给它们进行投票，每位选手投且仅投给一道题，其中第 iii 位选手所投票的题目编号为 aiaia_i。 由于投票的选手众多，所以王队长请你来帮忙统计得票数。你需要找出收获选手投票最多的题目数量与他们的编...
Loj X:创建逻辑电路-开源
07-04
Loj X 是一个开源项目，专注于提供一个平台，让人们能够创建和设计逻辑电路，从而实现基本的计算功能，甚至构建小型的完整处理器。这个工具集成了各种元件，如逻辑门、存储器和程序读取器，使得用户可以构建出复杂的...
CodePlus20184月赛解题报告与CSP-S复习资源
"正汰的旧博客备份OldBlogBackup，包含C++相关的博客内容，以及一个名为‘CSP-S复习计划’的文章链接，讨论了CodePlus20184月赛的解题报告，涉及多种算法和编程竞赛策略。" 在正汰的旧博客备份中，我们可以发现博主...
loj10155：数字转换：树的直径问题
liusu201601的博客
12-25 302
题目连接 树形DP专题 题目大意 一个数字n，求n以内的数字之间 “约数和关系” 的最长链； 约数和关系：一个数字 xxx 的约数和为 s[x]s[x]s[x] ； 题目分析 由 约数和关系 可以想到，如果 s[x]<xs[x]<xs[x]<x ，他们之间可以连一条双向边；题目就转换为了一个树上，求直径。 直径的定义： 树上最长的链。 求树的直径的方法1：用两次df...
bzoj5340/loj2552「CTSC2018」假面（期望与概率+背包dp）
Icefox的博客
05-08 711
这签到题送我见祖宗了啊qaq 全世界都A了这题，像我这样只拿了10分的傻子怕是不多了吧。我们考虑怎么求最后的期望生命值。 因为减到0血就不减了，所以我们不能直接每次期望算，只好考虑一个背包转移。 dp[i][j]表示i减了j滴血的概率。减了K[i]滴血就代表i死了。 每次攻击时对x做一个O(mi)的背包转移即可。 最后对每个人枚举减j滴血的情况计算即可。我们考虑“结界”询问。 即就是问活
【LOJ2321】「清华集训 2017」无限之环
cz_xuyixuan的博客
06-26 499
【题目链接】 点击打开链接 【思路要点】 先说这道题的正解： 将棋盘看做一张二分图，每一条边拆成两个点，分别属于二分图的一边。 我们需要做一件类似于匹配的事情，同一条边的两侧或是都没有管道，或是都有管道。 通过合适的建边我们能够用最小费用最大流来解决本题。 时间复杂度O(MinCostFlow(N∗M,N∗M))O(MinCostFlow(N∗...
[LOJ6259][CodePlus 2017 12 月赛]白金元首与独舞-矩阵树定理
「嫌われ者のフィロソフィ」
10-30 821
白金元首与独舞题目描述到河北省 见斯大林 / 在月光下 你的背影 / 让我们一起跳舞吧 うそだよ~ 河北省怎么可能有 Stalin。可是…… 可是如果 Stalin 把自己当作炸弹扔到地堡花园里来了呢？怀揣着这份小小的希望，元首 Adolf 独自走进了花园。终有一天会重逢的吧，Stalin。或许是在此处，或许是在遥远的彼方。无论如何，在此之前，好好装点一番花园，编排一段优美的舞步吧！元首把花园分为
【CodePlus 2017 12 月赛】白金元首与独舞
StrideTG的博客
03-31 404
时间限制 : 2000 MS 空间限制 : 512 MB 问题描述 样例输入 5 3 9 LLRRUDUUU LLR.UDUUU LLRRUDUUU 4 4 LLRR L.LL RR.R LLRR 4 3 LRD LUL DLU RDL 1 2 LR 2 2 .. .. 样例输出...
LOJ2341. 「WC2018」即时战略 [动态点分治]
dfn8726的博客
05-11 183
LOJ 思路 考虑最蠢的暴力：枚举2~n，从1拉一条到他们的链，需要查询\(n^2\)次，显然不能通过。 考虑优化：如果拉的第一个点已经被访问过了，那么类似二分的做法，一次往那个方向多跳几步。 多跳几步？那就动态点分治吧。每次最多跳\(\log n\)次就一定可以找到一个点使得它到你现在枚举的点的路径全都没有访问过，然后一次把这上面的点全都explore一边即可。 然而，树的形态你不知道...
10秒完成pip在线安装（Linux、Windows通用）
热门推荐
晨曦蜗牛
10-19 11万+
对于Python开发攻城狮及系统运维攻城狮来说，pip的安装那是必不可少的一个过程。鉴于网上很多安装过程写得过于复杂，本人根据pip官方手册总结了以下最为快捷的安装方式，只需要2步操作。 curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py python get-pip.py 或者直接运行以下代码： #!/usr/bin/env ...
【LOJ】#2341. 「WC2018」即时战略-LCT/动态点分治
远行客
03-12 384
LCT/动态点分治
【loj2341】【WC2018】即时战略
weixin_33724046的博客
05-07 85
题目 交互题； 一开始所有点都是黑的，你需要把所有点变白； explore(u,v)会将u到v路径上的第二个点变白； 一开始只有1号点是白色的，你需要让所有点变白； 对于一条链次数限制\(O(n+log \ n)\)，普通的树次数限制\(O(n \ log \ n)\) ; 题解 orz yww Part 1 白色区间一定是一条链，记录左右端点; 先假设新点在左边用左端点扩展，如果explore...
noip2016 Day2 T3：愤怒的小鸟 （状压DP+二进制压位）
KsCla
12-08 2005
题目描述 Kiana最近沉迷于一款神奇的游戏无法自拔。 简单来说，这款游戏是在一个平面上进行的。 有一架弹弓位于（0,0)处，每次Kiana可以用它向第一象限发射一只红色的小鸟，小鸟们的飞行轨迹均为形如y=ax^2+bx的曲线，其中a,b是Kiana指定的参数，且必须满足a。 当小鸟落回地面（即x轴）时，它就会瞬间消失。 在游戏的某个关卡里，平面的第一象限中有n只绿色的小猪，其中第i只小
BZOJ1492：[NOI2007]货币兑换Cash （CDQ分治+斜率优化DP/平衡树维护凸壳）
KsCla
09-02 1619
题目传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=1492题目分析：被一道水题坑了两天…… 首先朴素的O(n2)O(n^2)的DP是很好想的：记f[i]表示第i天不持有任何金券所能获得的最多人民币，很明显f[i]可以由f[i-1]更新而来（就是在1~i-1天就已经卖完所有金券，然后第i天不进行任何操作），还可以枚举一个j，看一下在第j天买入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值