插头DP小结

最新推荐文章于 2024-04-27 10:38:50 发布
最新推荐文章于 2024-04-27 10:38:50 发布
阅读量4.9k 收藏 2
点赞数 1
分类专栏： 插头dp 文章标签： 插头dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Quack_quack/article/details/50689028
版权

插头DP一般都是棋盘模型，找路径或者环路最值或者方案数。
插头：说白了就是两个联通的格子，一个走向另一个，那么这里就有一个插头。
轮廓线：DP逐格DP，那么轮廓线可以分开DP过的格子和未DP的格子。轮廓线的长度明显是m+1。插头垂直于轮廓线。
转移：
轮廓线在换行的时候要位移，这个画画图就出来了。
然后具体问题具体讨论。比如任意多个环路，不考虑方向，那么就是eat the trees，用最小表示法，因为是任意多个环路，那么插头只有两种，一种是有插头，一种是没插头，具体联通与否我们不管。如果要考虑方向呢？那么插头就有3种，一种是没插头，一种是插头从已DP的指向未DP的，一种是未DP的指向已DP的。
具体实现，有两种思路，一种是括号序列，一种是最小表示法。
括号序列比较快，空间压缩得很好，不过转移太麻烦辣。
最小表示法转移比较好想，就是比较慢，空间比较大。
写法有三种，一种是hash表存取状态，有decode，encode，就是kuangbin那种写法；一种是传统dp写法，位运算取出状态；还有种是claris写法，预处理所有可能状态然后传统DP转移。
kuangbin那个因为位运算比较少，每次都会直接接触到解密的状态，比较直观好想，模式化很强，不过每次都有O(m)的常数用在加密解密上。时空耗费较大，要写hash表，代码较长。
传统DP转移有的是O(1)，有的O(n)，总体来说和上面的差不多。。因为递推转移无效状态比较多。然后代码比较短。缺点就是一堆位运算像我这种傻逼根本看不懂
claris写法太神辣。因为所有状态预处理好了所以状态数很少，因为预处理所以所有转移O(1)，然后代码很短。缺点是我这种傻逼不会预处理。然后还是一堆位运算。并且遇到题目本身状态很多的时候效果不会很好。
我现在只会第一种写法。
下面扔2个例题。
HYSBZ 3125
找一条走过所有格子的环路的方案数。
有的格子只能上下经过，有的只能左右经过，有的不能经过。
这个题我写的括号序列。
插头3种，空插头，左括号，右括号。
然后分9类情况讨论即可。
因为分了9类情况所以代码长爆。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
const int HASH=10007,STATE=1000010,MAXD=15;
int n,m,ex,ey,code[MAXD];
char maze[MAXD][MAXD];
struct HASHMAP{
    int head[HASH],next[STATE],state[STATE],size;
    ll f[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof head);
    }
    void push(int st,ll val)
    {
        int h=st%HASH;
        for(int i=head[h];i!=-1;i=next[i])
            if(st==state[i])
            {
                f[i]+=val;
                return;
            }
        f[size]=val;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];
int encode(int *code,int m)
{
    int st=0;
    for(int i=0;i<=m;i++)
    {
        st*=3;
        st+=code[i];
    }
    return st;
}
void decode(int *code,int m,int st)
{
    for(int i=m;i>=0;i--)
    {
        code[i]=st%3;
        st/=3;
    }
}
void shift(int *code,int m)
{
    for(int i=m;i>0;--i)code[i]=code[i-1];
    code[0]=0;
}
void dpblank(int i,int j,int cur)
{
    for(int k=0;k<hm[cur].size;++k)
    {
        decode(code,m,hm[cur].state[k]);
        int &p=code[j-1],&q=code[j];
        if(!p&&!q)
        {
            if((maze[i+1][j]=='|'||maze[i+1][j]=='.')&&(maze[i][j+1]=='-'||maze[i][j+1]=='.'))
            {
                p=1,q=2;
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
        }
        else if(p&&q)
        {
            if(p==1&&q==1)
            {
                int tot=0;
                for(int ii=j;ii<=m;++ii)
                {
                    if(code[ii]==1)++tot;
                    if(code[ii]==2)--tot;
                    if(tot==0)
                    {
                        code[ii]=1;
                        break;
                    }
                }
                p=0,q=0;
                if(j==m)shift(code,m);
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
            else if(p==2&&q==2)
            {
                int tot=0;
                for(int ii=j-1;ii>=0;--ii)
                {
                    if(code[ii]==2)++tot;
                    if(code[ii]==1)--tot;
                    if(tot==0)
                    {
                        code[ii]=2;
                        break;
                    }
                }
                p=0,q=0;
                if(j==m)shift(code,m);
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
            else if(p==1&&q==2)
            {
                if(i==ex&&j==ey)
                {
                    p=0,q=0;
                    if(j==m)shift(code,m);
                    hm[cur^1].push(encode(code,m),hm[cur].f[k]);
                }
            }
            else if(p==2&&q==1)
            {
                p=0,q=0;
                if(j==m)shift(code,m);
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
        }
        else
        {
            if(maze[i][j+1]=='.'||maze[i][j+1]=='-')
            {
                q=p+q,p=0;
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
            if(maze[i+1][j]=='.'||maze[i+1][j]=='|')
            {
                p=p+q,q=0;
                if(j==m)shift(code,m);
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
        }
    }
}
void dpver(int i,int j,int cur)
{
    for(int k=0;k<hm[cur].size;++k)
    {
        decode(code,m,hm[cur].state[k]);
        int &p=code[j-1],&q=code[j];
        if(p==0&&q)
        {
            if(maze[i+1][j]=='.'||maze[i+1][j]=='|')
            {
                p=q,q=0;
                if(j==m)shift(code,m);
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
        }
    }
}
void dphor(int i,int j,int cur)
{
    for(int k=0;k<hm[cur].size;++k)
    {
        decode(code,m,hm[cur].state[k]);
        int &p=code[j-1],&q=code[j];
        if(p&&q==0)
        {
            if(maze[i][j+1]=='.'||maze[i][j+1]=='-')
            {
                q=p,p=0;
                hm[cur^1].push(encode(code,m),hm[cur].f[k]);
            }
        }
    }
}
void dpblock(int i,int j,int cur)
{
    for(int k=0;k<hm[cur].size;++k)
    {
        decode(code,m,hm[cur].state[k]);
        code[j-1]=0,code[j]=0;
        if(j==m)shift(code,m);
        hm[cur^1].push(encode(code,m),hm[cur].f[k]);
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
    {
        scanf("%s",maze[i]+1);
        for(int j=1;j<=m;++j)
            if(maze[i][j]=='.')ex=i,ey=j;
    }
    int cur=0;
    ll ans=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            hm[cur^1].init();
            if(maze[i][j]=='.')dpblank(i,j,cur);
            else if(maze[i][j]=='|')dpver(i,j,cur);
            else if(maze[i][j]=='-')dphor(i,j,cur);
            else dpblock(i,j,cur);
            cur^=1;
        }
    for(int i=0;i<hm[cur].size;++i)ans+=hm[cur].f[i];
    printf("%lld\n",ans);
}

bzoj2310 parkii
这个题就是弱化的zoj3213
棋盘上的格子有权值。找一条路径使路径上的权值之和最大。
这题我用的最小表示法，需要因为这个是路径不是回路，需要增加独立插头，同事需要增加标志位记录独立插头个数。要使独立插头个数小于等于2.具体实现的时候把标志位也压进状态里面。
最小表示法就相对好讨论一些。因为括号序列的性质，轮廓线上m+1个点最多只有m/2个不同的联通块，根据这个压位DP。
如果左插头和上插头都有，那么右插头和下插头就没有了。有以下2种情况：
1、如果左插头和上插头都有且不在一个联通块内，就连接他们。连接还要重标号最小表示。因为以前左插头所在联通块和上插头所在联通块不是一个，现在要暴力修改。
2、如果左插头和上插头都有且在一个联通块内，就不管了。
如果左插头和上插头只有一个，那么就有以下3种情况：
1、这个插头可以延续一个右插头
2、这个插头可以延续一个下插头
3、这个插头可以延续一个独立插头
注意延续一个右/下插头不要走出棋盘了，注意延续独立插头的前提是轮廓线上独立插头数量小于2
如果左插头和上插头都没有，那么就有以下3种情况：
1、右插头和下插头都得有，现在他们俩在一个联通块内。注意这样不要走出棋盘了。
2、左插头变成独立插头再延续一个右插头。注意延续独立插头的前提是轮廓线上独立插头数量小于2。
3、右插头变成独立插头再延续一个左插头。注意延续独立插头的前提是轮廓线上独立插头数量小于2。
这样就讨论完了。注意换行的时候状态要位移。如果用括号序列分类有16种= =这个我太傻逼了不会做。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int HASH=10007,STATE=1000010,MAXD=15;
int n,m,num,code[MAXD],ch[MAXD],maze[105][MAXD];
struct HASHMAP{
    int head[HASH],next[STATE],state[STATE],f[STATE],size;
    void init()
    {
        size=0;
        memset(head,-1,sizeof head);
    }
    void push(int st,int val)
    {
        int h=st%HASH;
        for(int i=head[h];~i;i=next[i])
            if(st==state[i])
            {
                f[i]=max(f[i],val);
                return;
            }
        f[size]=val;
        state[size]=st;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];
int encode(int *code,int m)
{
    int st=0,cnt=1;
    memset(ch,-1,sizeof ch);
    ch[0]=0;
    for(int i=0;i<=m;++i)
    {
        if(ch[code[i]]==-1)ch[code[i]]=cnt++;
        code[i]=ch[code[i]];
        st<<=3;
        st|=code[i];
    }
    st<<=3;
    st|=num;
    return st;
}
void decode(int *code,int m,int st)
{
    num=st&7;
    st>>=3;
    for(int i=m;i>=0;--i)
    {
        code[i]=st&7;
        st>>=3;
    }
}
void dp(int i,int j,int cur)
{
    for(int k=0;k<hm[cur].size;++k)
    {
        decode(code,m,hm[cur].state[k]);
        int p=code[j-1],q=code[j];
        if(p&&q)
        {
            if(p!=q)
            {
                for(int ii=0;ii<=m;++ii)
                    if(code[ii]==q)code[ii]=p;
                code[j-1]=code[j]=0;
                hm[cur^1].push(encode(code,j==m?m-1:m),hm[cur].f[k]+maze[i][j]);
            }
        }
        else if(p||q)
        {
            if(j+1<=m)
            {
                code[j]=p+q,code[j-1]=0;
                hm[cur^1].push(encode(code,m),hm[cur].f[k]+maze[i][j]);
            }
            if(i+1<=n)
            {
                code[j-1]=p+q,code[j]=0;
                hm[cur^1].push(encode(code,j==m?m-1:m),hm[cur].f[k]+maze[i][j]);
            }
            if(num<2)
            {
                ++num;
                code[j-1]=code[j]=0;
                hm[cur^1].push(encode(code,j==m?m-1:m),hm[cur].f[k]+maze[i][j]);
            }
        }
        else
        {
            code[j-1]=code[j]=0;
            hm[cur^1].push(encode(code,j==m?m-1:m),hm[cur].f[k]);
            if(j+1<=m&&i+1<=n)
            {
                code[j-1]=code[j]=13;
                hm[cur^1].push(encode(code,m),hm[cur].f[k]+maze[i][j]);
            }
            if(num<2)
            {
                ++num;
                if(j+1<=m)
                {
                    code[j-1]=0,code[j]=13;
                    hm[cur^1].push(encode(code,m),hm[cur].f[k]+maze[i][j]);
                }
                if(i+1<=n)
                {
                    code[j-1]=13,code[j]=0;
                    hm[cur^1].push(encode(code,j==m?m-1:m),hm[cur].f[k]+maze[i][j]);
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            scanf("%d",&maze[i][j]);
    int cur=0,ans=-999999999;
    hm[cur].init();
    hm[cur].push(0,0);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            ans=max(ans,maze[i][j]);
            hm[cur^1].init();
            dp(i,j,cur);
            cur^=1;
        }
    for(int i=0;i<hm[cur].size;++i)ans=max(ans,hm[cur].f[i]);
    printf("%d\n",ans);
}
Quack_quack
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【学习小结】插头DP
执子之手,与子偕老
04-10 150
论文部分 orz litble 基于连通性的状态压缩方法 1. 最小表示法压缩联通块 可以把联通块从左到右最小标号。也可以按照同一联通块中的最小下标标号 2. 对于路径用括号序表示 因为路径不可能相交，所以这样表示可以大大减少状态 如果不是回路，而是路径，记录独立插头，但独立插头最多只有两个 3. 只对插头状压连通性 其他部分因为已经联通，不用考虑 4. 最后用hash来存状态 直接在插入状态的时...
插头dp小结
curry的博客
01-25 171
基于连通性状态压缩的动态规划
6.10 ACM-ICPC动态规划算法 插头 DP
tang7mj的博客
04-27 1361
插头 DP 通常用于解决格点图中需要记录连通性的问题。这包括但不限于哈密顿路径计数、棋盘黑白染色问题、特定图的生成树计数等。在这类问题中，我们需要对状态的连通性进行编码，并且在状态转移过程中考虑连通性的变化。插头 DP 是一种解决连通性问题的高级动态规划技术，在 ACM-ICPC 等竞赛中非常有用。虽然编码难度较大，涉及的状态转移较为复杂，但插头 DP 能够解决传统动态规划方法无法处理的问题。了解并掌握插头 DP，可以显著提高参赛者解决连通性问题的能力，为他们在竞赛中获得佳绩提供了可能。
插头DP学习小结
WorldWide_D的博客
02-23 2391
插头dp一般可以解决一类需要记录联通状态的题目（比如一个棋盘求满足某某条件的路径等）。定义插头一个格子如果与它正上方的格子联通，则有一个上插头，下左右亦然。轮廓线我们解决问题的时候，一般是外循环从上到下枚举，第二重循环从左到右枚举。那么当决策到(i,j)时，轮廓线就是(i,1)—(i,j-1)的下方，(i,j-1)的右方和(i-1,j)—(i-1,m)连接成长度m+1的线，在这里记录的状态是m个下插
[原创]插头DP小结（ACM by kuangbin）
weixin_34066347的博客
10-02 103
这几天学习了一下插头DP，刷了11道题。对插头DP有了点理解。插头DP就先告一段落吧！ 后面还有插头DP的广义路径和其它复杂应用，以后有机会再补上吧！       kuangbin     首先入门推荐的还是cdq的论文：《基于连通性状态压缩的动态规划问题》 http://wenku.baidu.com/view/4fe4ac659b6648d7c1c74633.html 上面的论文关...
轮廓线dp小结
a_forever_dream的博客
11-25 925
介绍 本质上是状压dp，所以是用在一类数据范围很小的题中，一般是求方案数之类的。 正题 这个东西大家有时候也管他叫插头dp，个人认为插头dp只是轮廓线dp的一种，只是把轮廓线上的状态设计成插头而已，事实上也可以不是插头，确实也有这样的题。 不过插头dp可能更广为人知，这里就以一道经典题作为例题： 给出一张网格图，每个位置是.或*，*表示这个位置不可用，你要在可用的位置上设计一条哈密顿回路，经过所有可用点。链接 不知道这道题的话还是看一眼原题比较好qwq。 先说轮廓线是什么东西，说清楚也很简单，就是下面的
插头$DP$学习小结
weixin_30293079的博客
12-13 67
插头\(DP\)学习小结 这种辣鸡毒瘤东西也能叫算法。。。 很优秀的一个算法。 最基本的适用范围主要是数据范围极小的网格图路径计数问题。 如果是像\(Noi2018\)那种的话建议考生在其他两道题难度超过普及组的情况下放弃这题。 其实大佬想做也可以去刚一下 切记如果在考场上看到这种题目，千万不要觉得你看出正解就是切了此题。 请一定将插头\(DP\)题当做一道毒瘤大模拟看待。 要点 这种东西细节挺...
插头dp
梦醒了
05-24 723
插头DP小结? 因为独立插头还有最小表示法没有打过，独立插头没看懂，广义路径连看都没看过，所以这些不再本文的总结范围内。 去年学插头DP的时候还是很惧怕的，也只做了一题，还是按着课件对着标程打的。还好今年终于懂得原理了。其实打多了也变成模板了（当然每题的转移不一样）。 插头DP有下面的分类： 按模型：多回路问题、单回路问题、简单路径问题、广义路径问题 按表示方法：是否有插头、括号法（
2019/3/17训练日记 DP思想小结
胖亚亚的小酒馆
03-17 835
最近是刷的dp专题，其下划分的种类确实挺多的，背包、区间dp、状压dp、概率dp、树形dp、数位dp、插头dp、优化dp、和字符串结合的dp...最近做的都是一些简单的dp，这些都不重要，重要的是锻炼dp的这种思想 dp的基本思想是什么？把求解的问题划分成多个子问题，然后按顺序求解各子问题，前一子问题的求解为后一子问题的求解提供了重要的信息，后一子问题需要根据某种决策来选取前一子问题的解以便解出...
【总结】插头DP-bzoj1210/2310/2331/2595
远行客
11-25 335
插头DP小结
插头DP模板待完成.md
02-23
未完成的ＤＰ
简单插头DP的模板
11-26
传说中插头DP的模板，参考陈丹琦大牛的论文写的，这只是前面的简单部分的模板，后面的高深部分就木有了。。。
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
pi_heif-0.17.0-pp310-pypy310_pp73-macosx_12_0_x86_64.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
mmexport1722080103662.jpg
07-27
mmexport1722080103662.jpg
matlab 20244a 6
07-27
matlab 20244a 6
NOIP进阶：插头DP策略与连通性状态压缩解析
"该资源是针对NOIP基础学习的课件，主要讲解了插头DP这一动态规划策略，由金牌选手制作，适用于准备NOIP竞赛的学习者。" 在动态规划领域，插头DP是一种有效的方法，尤其适用于处理具有连通性特征的问题。此课件由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值