插头dp

最新推荐文章于 2022-09-25 09:26:08 发布
最新推荐文章于 2022-09-25 09:26:08 发布
阅读量454 收藏
点赞数 1
分类专栏： ACM学习 文章标签： dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q437634645/article/details/65449787
版权

插头dp从入门到不会


POJ 2411 Mondriaan's Dream

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <ctime>

using namespace std;

#define ll long long

const int maxn=12;

ll dp[maxn*maxn+50][(1<<maxn)+50];

int main(){
    int n,m;
    while(scanf("%d %d",&n,&m)==2&&(n||m)){
        if(n<m)swap(n,m);
        memset(dp,0,sizeof(dp));
        dp[0][0]=1;
        int st=1<<(m+1);
        int cot=0;
        int flag;
        int ne;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                //保证合法递推
                for(int s=0;s<st;s++)if(dp[cot][s]>0){
                    flag=(s>>m)|(s&1);//获取位置位置
                    ne=(s<<1)&(~3);//右移并空出最后两位
                    ne=ne&((1<<(m+1))-1);//保留m位信息
                    if(!flag){

                        if(i!=n-1)dp[cot+1][ne|2]+=dp[cot][s];
                        if(j!=m-1&&((s>>(m-1))&1)==0)dp[cot+1][ne|1]+=dp[cot][s];
                    }
                    else dp[cot+1][ne]+=dp[cot][s];
                }
                cot++;
            }
        }
        printf("%lld\n",dp[cot][0]);
    }
    return 0;
}


HDU 1565 方格取数(1)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <ctime>

using namespace std;

#define ll long long

const int maxn=25;

ll grap[maxn][maxn];
ll dp[2][(1<<20)+50];

int main(){
    int n;
    int p;
    while(scanf("%d",&n)==1){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                scanf("%lld",&grap[i][j]);
            }
        }
        p=0;
        memset(dp,-1,sizeof(dp));
        dp[p][0]=0;
        int st=1<<n;
        ll ans=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int s=0;s<st;s++)if(dp[p][s]!=-1){
                    if(s&(1<<j))dp[p^1][s^(1<<j)]=max(dp[p][s],dp[p^1][s^(1<<j)]);
                    else if(j!=0&&(s&(1<<(j-1))))dp[p^1][s^(1<<j)]=max(dp[p][s],dp[p^1][s^(1<<j)]);
                    else dp[p^1][s^(1<<j)]=max(dp[p][s]+grap[i][j],dp[p^1][s^(1<<j)]);
                    dp[p^1][s&(~(1<<j))]=max(dp[p][s],dp[p^1][s&(~(1<<j))]);
                }
                p^=1;
            }
        }
        for(int s=0;s<st;s++)ans=max(ans,dp[p][s]);
        printf("%lld\n",ans);
    }
    return 0;
}

HDU 2167 Pebbles

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <ctime>

using namespace std;

#define ll long long

const int maxn=16;

int dp[2][(1<<maxn)+50];
int num[maxn+5][maxn+5];
/*int n;
int m;

bool read(){
    n=0;
    m=0;
    char ch;
    int cot=0;
    num[n][m]=0;
    while(cot<2){
        ch=getchar();
        if(ch>='0'&&ch<='9'){
            cot=0;
            num[n][m]=num[n][m]*10+ch-'0';
        }
        else if(ch==' '){
            cot=0;
            num[n][++m]=0;
        }
        else if(ch=='\n'){
            if(!cot)n++;
            m=0;
            num[n][m]=0;
            cot++;
        }
        else if(ch==EOF){
            if(!cot)n++;
            return false;
        }
    }
    return true;
}*/

char s[maxn*maxn];

int main(){
    //printf("%d\n",sizeof(num)+sizeof(dp));
    //freopen("in.txt","r",stdin);
    int ne;
    int flag;
    while(true){
        int n=16;
        int t=0;
        int st=1<<(n+1);
        memset(dp,-1,sizeof(dp));
        int p=0;
        dp[0][0]=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                char ch;
                if(scanf("%d%c",&num[i][j],&ch)==-1)return 0;
                t++;
                if(ch=='\n'&&n==16)n=t;
            }
        }
        st=1<<(n+1);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int s=0;s<st;s++)if(dp[p][s]!=-1){
                    if(j==0)flag=(s>>(n-2))&3;
                    else if(j==n-1)flag=(s>>(n-1))|(s&1);
                    else flag=(s>>(n-2))|(s&1);//获取邻格信息
                    ne=(s<<1)&((1<<(n+1))-1);
                    if(!flag)dp[p^1][ne|1]=max(dp[p^1][ne|1],dp[p][s]+num[i][j]);
                    dp[p^1][ne]=max(dp[p^1][ne],dp[p][s]);
                }
                memset(dp[p],-1,sizeof(dp[p]));
                p^=1;
            }
        }
        int ans=0;
        for(int s=0;s<st;s++)ans=max(dp[p][s],ans);
        printf("%d\n",ans);
    }
    return 0;
}


HDU 1693 Eat the Trees

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <ctime>

using namespace std;

#define ll long long

const int maxn=11;

ll dp[2][532000];
int num[maxn+5][maxn+5];
int pow3[maxn+5];
int pos[maxn+5];
int tmp[maxn+5];

int getstate(int pos[],int m){
    int res=0;
    for(int i=0;i<=m;i++)
        res+=pos[i]*pow3[i];
    return res;
}

int main(){
    pow3[0]=1;
    for(int i=1;i<=maxn+2;i++)pow3[i]=pow3[i-1]*3;
    int t;
    int n,m;
    scanf("%d",&t);
    for(int kase=1;kase<=t;kase++){
        scanf("%d %d",&n,&m);
        //if(n<m)swap(n,m);
        memset(dp,0,sizeof(dp));
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                scanf("%d",&num[i][j]);
        int st=pow3[m+1];
        int L,T;
        int p=0;
        dp[0][0]=1;
        for(int i=0;i<n;i++){
            for(int s=0;s<st;s++)if(dp[p][s]){
                int ss=s;
                for(int k=1;k<=m;k++){
                    tmp[k]=ss%3;
                    ss/=3;
                }
                //if(ss!=0)continue;
                tmp[0]=0;
                dp[p^1][getstate(tmp,m)]=dp[p][s];
            }
            memset(dp[p],0,sizeof(dp[p]));
            p^=1;
            for(int j=0;j<m;j++){
                for(int s=0;s<st;s++)if(dp[p][s]){
                    int ss=s;
                    for(int k=0;k<=m;k++){
                        pos[k]=ss%3;
                        ss/=3;
                    }
                    if(num[i][j]==0){
                        memcpy(tmp,pos,sizeof(tmp));
                        tmp[j]=tmp[j+1]=0;
                        dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        continue;
                    }
                    L=j;
                    T=j+1;
                    if(pos[L]==0&&pos[T]==0&&j!=m-1&&i!=n-1&&num[i+1][j]&&num[i][j+1]){
                        memcpy(tmp,pos,sizeof(tmp));
                        tmp[j]=1;tmp[j+1]=2;
                        dp[p^1][getstate(tmp,m)]+=dp[p][s];
                    }
                    if(pos[L]&&pos[T]==0){
                        if(i!=n-1&&num[i+1][j]){
                            memcpy(tmp,pos,sizeof(tmp));
                            tmp[j]=pos[L];tmp[j+1]=0;
                            dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        }
                        if(j!=m-1&&num[i][j+1]){
                            memcpy(tmp,pos,sizeof(tmp));
                            tmp[j]=0;tmp[j+1]=pos[L];
                            dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        }
                    }
                    if(pos[L]==0&&pos[T]){
                        if(j!=m-1&&num[i][j+1]){
                            memcpy(tmp,pos,sizeof(tmp));
                            tmp[j]=0;tmp[j+1]=pos[T];
                            dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        }
                        if(i!=n-1&&num[i+1][j]){
                            memcpy(tmp,pos,sizeof(tmp));
                            tmp[j]=pos[T];tmp[j+1]=0;
                            dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        }
                    }
                    if(pos[L]&&pos[T]){
                        if(pos[L]!=pos[T]){
                            memcpy(tmp,pos,sizeof(tmp));
                            tmp[j]=tmp[j+1]=0;
                            dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        }
                        else {
                            memcpy(tmp,pos,sizeof(tmp));
                            tmp[j]=tmp[j+1]=0;
                            int cot=0;
                            if(pos[j+1]==1)
                            for(int l=j+2;l<=m;l++){
                                if(pos[l]==1)cot++;
                                else if(pos[l]==2){
                                    if(cot--==0)tmp[l]=1;
                                }
                            }
                            else if(pos[j+1]==2)
                            for(int l=j-1;l>=0;l--){
                                if(pos[l]==2)cot++;
                                else if(pos[l]==1){
                                    if(cot--==0)tmp[l]=2;
                                }
                            }
                            dp[p^1][getstate(tmp,m)]+=dp[p][s];
                        }
                    }
                }
                memset(dp[p],0,sizeof(dp[p]));
                p^=1;
                /*for(int s=0;s<st;s++){
                    printf("%d ",dp[p][s]);
                }
                puts("");*/
            }
        }
        printf("Case %d: There are %lld ways to eat the trees.\n",kase,dp[p][0]);
    }
    return 0;
}



URAL 1519 Formula 1

...待填

URAL 1520 Empire Strikes Back

...待填

FZU 1977 Pandora adventure

...待填

HDU 1964 Pipes

...待填

HDU 3377 Plan

...待填

POJ 1739 Tony's Tour

...待填

POJ 3133 Manhattan Wiring

...待填

ZOJ 3466 The Hive II

...待填

ZOJ 3256 Tour in the Castle

...待填

ZOJ 3213 Beautiful Meadow

...待填

HDU 4285 circuits

...待填

q437634645
关注
专栏目录
插头DP/轮廓线DP
EricQian的博客
02-07 609
题解 P5056 【【模板】插头dp】- GNAQ (\(\uparrow\) 学习资料，大部分贺的，有一些些的改动与自己的补充) 什么是插头 DP 插头 DP 是一类用状压 DP 来处理连通性问题的 DP 方法。 常见的类型：棋盘插头 DP、连通性问题(回路问题，路径问题，生成树问题等)…… 插头 DP 的大致思路 划分状态 插头 DP 本质上式状压 DP！ 一般设 \(dp(i,state,...
【模板】插头dp
a6t2007的博客
01-07 204
题目描述 题解： 插头$dp$中经典的回路问题。 首先了解一下插头。 一个格子，上下左右四条边对应四个插头。就像这样： 四个插头。 一个完整的哈密顿回路，经过的格子一定用且仅用了两个插头。 所以所有被回路经过的格子有六种状态，即左上，左右，左下，上右，上下，右下。 这几个就是插头$dp$的基本。 然后我们来了解一下轮廓线。 红线就叫轮廓线。 我们可以利用轮廓...
插头DP_最小表示法 模板详解
A_Bo的博客
04-30 1802
声明模板来自：https://www.cnblogs.com/kuangbin/archive/2012/09/29/2708989.html算法说明如果还不知道插头dp中插头以及轮廓线等概念是什么东西的话，请移步：插头与轮廓线与基于连通性状态压缩的动态规划然后对于什么是最小表示法，请移步：《基于连通性状态压缩的动态规划问题  陈丹琪》那么这里就简单说一下状态的转移：对于m列的格子，用一个m+1的...
插头DP模板待完成.md
02-23
未完成的ＤＰ
插头dp。
hungry1234的博客
03-16 519
插头dp解决网格问题 轮廓线 就是格子的边 每次维护一个格子周围的状态，使之能够不重不漏的表示所有格子的状态 吃树 题意：求若干回路覆盖所有格子的方案数 枚举每个格子，维护包围着一个格子的轮廓线 对于每一行，已经处理过的格子轮廓线是格子的底边，要处理的格子由一条向左和向下（左边和顶边）的轮廓线包含，其他未处理的格子的轮廓线就是格子的顶边 就是这样 二进制压位，用1表示这条轮廓线有连向此点的边，0表示没有 分类讨论一个格子左方和上方有没有边与这个格子连接进行转移： 若这个格子是障.
插头DP——从不会到入门（POJ 2411，HDU 1565，HDU 2167，HDU 1693，Ural 1519）
SF-_- 的 ACM 博客
11-10 1万+
#include #include #include #include using namespace std; #define LL long long const int maxn=100037; // 可能的最大状态数 struct Node { int H[maxn]; // 哈希 int S[maxn]; // 状态 LL N[maxn]; // 状态对应的数量 in
插头DP
g21wcr的博客
10-17 357
入坑题 参考博客 适用范围：数据范围极小，与连通性有关，网格图。 转移时用括号序来表示插头情况，然后分类讨论一下当前格子的左轮廓与上轮廓，也就是看有没有右插头与下插头，主要分为三大类： ①两个插头都没有 ②只有一个插头 ③两个插头都有 再分别讨论一下插头是“(”“(”“(”还是“)”“)”“)”即可。 当一层转移完时，要从这一层的最后一个格子跳到下一层的第一个格子。那么当前所有的合法状态的四进制表...
dp-插头dp
w75779的博客
09-25 1039
插头dp 真的烦
插头DP【入门】
热门推荐
jxy859的专栏
09-26 1万+
强烈推荐网址：http://www.notonlysuccess.com/?p=931   hdu 1693 Eat the Trees 多回路的不用判联通状态，二进制即可，转移情况2*2种。 时间O(n*m*2^n)  空间O（n*2^n） /**插头DP**/ #include #include const int maxm=13 ; const int maxn=1<<12;
插头dp/轮廓线dp
_Griefs
08-24 353
先%mmh学长。 这个东西还好吧。。。。 也算是个状压，难的也不会，就会写个板子题。 用哈希map代替了哈希表。 一、P5056 【模板】插头dp： 题目背景 ural 1519 陈丹琦《基于连通性状态压缩的动态规划问题》中的例题 题目描述 给出n*m的方格，有些格子不能铺线，其它格子必须铺，形成一个闭合回路。问有多少种铺法？ 输入格式 第1行，n,m(2<=n,m<=12) 从第2行...
hash表及带注释插头dp
weixin_30484739的博客
07-28 125
struct hash_map { node s[SZ+10];int e,adj[SZ+10]; inline void init(){e=0;memset(adj,0,sizeof(adj));} inline void update(LL state,int val,int cnt) { RG int i,pos=(s...
插头DP模板：哈密顿回路解析
"简单的插头DP模板，适用于解决哈密顿回路问题，来源于陈丹琦的论文，包括基础部分的代码实现。" 在计算机科学中，动态规划（Dynamic Programming，简称DP）是一种强大的算法设计方法，用于解决多阶段决策过程中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值