ZOJ3466

最新推荐文章于 2016-02-28 22:07:02 发布
最新推荐文章于 2016-02-28 22:07:02 发布
阅读量860 收藏 1
点赞数
分类专栏： ACM--题解汇总 ACM--插头DP 文章标签： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013480600/article/details/20639709
版权

ZOJ3466 The Hive II

       有一个N行8列的蜂窝，有一些格子里有蜜蜂，有些没有，现在要你在这个蜂窝里找几条回路使得这些回路里的格子正好有蜂蜜，且所有格子都在一个回路里，问你有多少种方法找到这些回路。

蜂窝里的小网格用两个大写字母标记其坐标.如下图：

输入：包含多组实例。每个实例第一行是N(0 < N ≤ 10)和M (0 ≤ M ≤ N * 8)，N表示行，M表示接下来有M个格子是没有蜂蜜的（其他N*8-M个格子都有蜂蜜）。

输出：输出构成这些回路的方法数，保证结果在int范围内。

分析：本题是插头DP的变形，咋一看挺复杂的，其实慢慢分析根据模板来做还是挺简单的。首先必须把输入的矩阵的行和列颠倒，然后继续逐格递推，但是轮廓线的长度不是M+1了，而是2*M+1，这个需要注意。而且处理当前格的时候，每次要考虑的插头由两个变成了3个。当刚行是奇数行或偶数行的时候，它的左下格，右下格，和右格要分情况讨论且当处理到最后一列的时候，轮廓线移位也要分情况讨论。

4边形就是2个入插头2个出插头，6边形就是3个入插头3个出插头，8边形就是4个入插头4个出插头。

AC代码：1990ms

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=2000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 10007;
const int MAXD=32;
int N,M;
int cur;
int mp[MAXD][MAXD];
int code[MAXD];
long long sum;//记录最终的最大值
struct HASHMAP
{
    int size,head[HASH],next[STATE];//next[i]=j表示第i个状态后面链接着第j个状态
    int state[STATE];//state[i]=S表第i个状态是S
    long long f[STATE];//f[i]=x表第i个状态有x种情况
    void init()
    {
        memset(head,-1,sizeof(head));
        size=0;
    }
    void push(int st, long long num)
    {
        int h = st%HASH;
        int i;
        for(i=head[h]; i!=-1; i=next[i])
        {
            if(state[i]==st)
            {
                f[i]+=num;
                return ;
            }
        }
        next[size]=head[h];
        head[h]=size;
        f[size]=num;
        state[size]=st;
        size++;
    }
} hm[2];
void decode(int *code,int st)//st->code
{
    for(int i=2*M; i>=0; i--)
    {
        code[i]=st&1;
        st>>=1;
    }
}
int encode(int *code)//code->st
{
    int st=0;
    for(int i=0; i<=2*M; i++)
    {
        st<<=1;
        st|=code[i];
    }
    return st;
}
void shift(int *code,int r)
{
    if(r%2==1)//只有奇数行到偶数行才需要右移两位，前端添0
    {
        for(int i=2*M; i>=2; i--)
            code[i]=code[i-2];
        code[0]=code[1]=0;
    }

}
void dpblock(int i,int j)//坏格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        int st=hm[cur].state[k];
        int code[MAXD];
        decode(code,st);
        int left=code[2*j-2] ,up=code[2*j-1],right=code[2*j];
        if(left==0&&up==0&&right==0)//全无插头时,才能生成新状态
        {
            if(j==M)//j为当前行最后一列,需要右移一位
                shift(code,i);
            hm[1-cur].push(encode(code),hm[cur].f[k]);
        }
    }
}
void dpblank(int i,int j)//好格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        int st=hm[cur].state[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j*2-2] ,up=code[j*2-1],right=code[j*2];
        if(left&&up&&right)//3端都有插头，不处理
        {
            continue;
        }
        else if( (left&&up) || (left&&right) ||(up&&right) )//只有两个插头,直接合并即可
        {
            code[j*2-2]=code[j*2-1]=code[j*2]=0;
            if(j==M)
                shift(code,i);
            hm[1-cur].push(encode(code),hm[cur].f[k]);
        }
        else if( left||up||right )//只有一个插头时
        {
            if(i%2==1)//奇数行时
            {
                if(mp[i+1][j])//（i，j）的左下格可行
                {
                    code[j*2-2]=1;
                    code[j*2-1]=0;
                    code[j*2]=0;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i+1][j+1])//（i，j）的右下格可行
                {
                    code[j*2-2]=0;
                    code[j*2-1]=1;
                    code[j*2]=0;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i][j+1])//（i，j）的右格可行
                {
                    code[j*2-2]=0;
                    code[j*2-1]=0;
                    code[j*2]=1;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
            }
            else if(i%2==0)//偶数行时
            {
                if(mp[i+1][j-1])//（i，j）的左下格可行
                {
                    code[j*2-2]=1;
                    code[j*2-1]=0;
                    code[j*2]=0;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i+1][j])//（i，j）的右下格可行
                {
                    code[j*2-2]=0;
                    code[j*2-1]=1;
                    code[j*2]=0;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i][j+1])//（i，j）的右格可行
                {
                    code[j*2-2]=0;
                    code[j*2-1]=0;
                    code[j*2]=1;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
            }
        }
        else//无插头,则生成新插头
        {
            if(i%2==1)//奇数行
            {
                if(mp[i+1][j]&&mp[i+1][j+1])//左下，右下可行
                {
                    code[j*2-2]=1;
                    code[j*2-1]=1;
                    code[j*2]=0;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i+1][j]&&mp[i][j+1])//左下，右格可行
                {
                    code[j*2-2]=1;
                    code[j*2-1]=0;
                    code[j*2]=1;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i+1][j+1]&&mp[i][j+1])//右下，右格可行
                {
                    code[j*2-2]=0;
                    code[j*2-1]=1;
                    code[j*2]=1;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
            }
            else if(i%2==0)//偶数行
            {
                if(mp[i+1][j-1]&&mp[i+1][j])
                {
                    code[j*2-2]=1;
                    code[j*2-1]=1;
                    code[j*2]=0;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i+1][j-1]&&mp[i][j+1])
                {
                    code[j*2-2]=1;
                    code[j*2-1]=0;
                    code[j*2]=1;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
                if(mp[i+1][j]&&mp[i][j+1])
                {
                    code[j*2-2]=0;
                    code[j*2-1]=1;
                    code[j*2]=1;
                    if(j==M)
                        shift(code,i);
                    hm[1-cur].push(encode(code),hm[cur].f[k]);
                }
            }
        }
    }
}
void init()
{
    N=8;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            mp[i][j]=1;
        }
    }
    char str[20];
    int t;//有t个格子没蜂蜜
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",str);
        mp[str[1]-'A'+1][str[0]-'A'+1]=0;
    }
}
void solve()
{
    sum=0;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,1);
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
            if(mp[i][j])
                dpblank(i,j);
            else
                dpblock(i,j);
            cur=1-cur;
            //printf("****************************************\n");
            //printf("(i,j)=(%d,%d),size=%d\n",i,j,hm[cur].size);
            //for(int k=0; k<hm[cur].size; k++)
                //printf("第%d个状态是%I64d\n",k,hm[cur].state[k]);
            //printf("\n");

        }
    for(int i=0; i<hm[cur].size; i++)
        sum+=hm[cur].f[i];
    printf("%lld\n",sum);
}
int main()
{
    while(scanf("%d",&M)==1&&M)
    {
        init();
        solve();
    }
    return 0;
}


focus_best
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zoj 3466（插头DP 多条回路 六边形）
志当存高远
06-06 1593
The Hive II Time Limit: 5 Seconds      Memory Limit: 65536 KB There is a hive in the village. Like this. There are 8 columns(from A to H) in this hive. Different colums have the same number of g
ZOJ 3466 The Hive II 解题报告（插头DP）
SF-_- 的 ACM 博客
11-12 1035
The Hive II Time Limit: 5 Seconds      Memory Limit: 65536 KB There is a hive in the village. Like this. There are 8 columns(from A to H) in this hive. Different colums have the same number of g
ZOJ 3466 The Hive II
imut zcy,I promise You.
05-13 466
正六边形形成的格子的单回路数。 与
ZOJ 3466 The Hive II 插头DP
Indestinee
11-22 365
题意： 给定一个n*8（
插头与轮廓线与基于连通性状态压缩的动态规划
weixin_33916256的博客
08-07 121
插头与轮廓线与基于连通性状态压缩的动态规划 问题定义 什么是插头DP 在一个n*m的棋盘上（n与m很小），求： 有多少种不同的回路数 用1条回路经过所有点的方案数 用1条回路经过部分点的方案数 1条路径上的权值和最大 的这一类问题，通常可以用插头DP来解决。 这类问题通常很明显，但代码量大又容易出错，有时TLE有时M...
ZOJ1046
qust1508060414的博客
01-27 300
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1046 抄答案。 枚举每一个符号，先判断能否只用一个像素来标记，不能的话判断能否用两个像素标记。只要有一个符号不能用一个或两个像素标记时就impossible。 判断一个符号能否用一个（或两个）像素标记时，枚举这个符号中的每一个（或两个）像素，看其他符号的相同
ZOJ1064
qust1508060414的博客
02-28 285
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=1064 不算难，只是代码看起来有点恶心。 首先是用Floyd求各个路口之间的最短路，储存在数组path里。 然后计算任意一个路口 i 与任意一个城市 j 之间最短路经过的第一个路口（即路口 i 和该路口之间有一条边），记录在 shortPath[i][j] 里
zoj 1002_zoj1002_
09-29
【标题】"ZOJ 1002" 是一个在线编程竞赛题目，源自ZOJ（Zhejiang Online Judge），这是一个面向ACM/ICPC（国际大学生程序设计竞赛）的在线评测系统。题目编号1002，通常表示该题是ZOJ平台上的一个问题，可能涉及算法...
zoj.zip_zoj
09-24
【标题】"zoj.zip_zoj"所对应的资源是一个与ZOJ（Zhejiang Online Judge）相关的代码集合。ZOJ是浙江大学主办的一个在线编程竞赛平台，它提供了多种算法题目供用户练习和提交代码进行评测。这个压缩包很可能包含了在...
zoj1383_zoj1383_
09-30
标题“zoj1383_zoj1383_”和描述中的“一个非常非常非常非常实用的zoj结题代码”暗示我们这可能是一个关于ZOJ（在线判题系统Zhejiang Online Judge）的编程挑战解决方案。ZOJ是一个为编程爱好者提供在线编程练习和...
ZOJ4.16.rar_zoj
09-21
ZOJ4.16.rar_zoj 是一个与ZOJ（Zhejiang Online Judge）相关的压缩文件，这通常意味着它包含了某次程序设计竞赛，特别是2004年4月16日浙江省程序设计竞赛的题目。ZOJ是浙江大学主办的一个在线编程平台，它允许参赛者...
zoj.rar_zoj_zoj4041
09-23
《ZOJ 4041问题的正确解法与程序分析》 ZOJ（Zhejiang Online Judge）是一个知名的在线编程竞赛平台，其中的题目编号为4041的题目吸引了众多程序员的关注。本篇文章将深入探讨ZOJ 4041的正确解法，并对提供的源代码...
zoj 3466 The Hive II(插头dp)
ACM之梦
01-30 465
题意： 给出蜂巢形状的地图，有障碍物，求走遍蜂巢的回路个数 题解： 多回路的加强版，这题真心难做，很难想到，按照列dp会更简单点。具体看代码 #include #include #include #include #include #include #include using namespace std; typedef long long lld; #define oo 0x3
HDU3377
code
03-04 1254
HDU3377 Plan 现在给你一个N*M的矩阵，矩阵每个格子都有一个分数，现在要求你从矩阵左上角走到矩阵右下角去能获得的最大分数。 输入：包含多组实例。每个实例首先是一行N和M，然后是这个矩阵，矩阵中的每个分数在[-2000，2000]内。 输出：从左上角走到右下角的最大分数。 分析：除了左上角和右下角外其他格子都是可选择的，不能构成一个圈。我们在这N*M的矩阵上再加一行一列（加第一行
POJ3133
code
03-05 1210
POJ3133 Manhattan Wiring 现在有一个N*M（2 输入：包含多组实例。每个实例第一行为N和M，然后是数字矩阵。输入以0和0结束。 输出：输出最小的短长度，如果不存在这样的两条线，就输出0. 分析：插头DP问题，只要按常规的插头DP问题来处理即可，但是要分别特殊处理2和3格子，然后用f[]记录最小长度即可。插头只有3种，0插头（表示无），2插头和3插头。 会不会出现4
HDU 4285
code
03-07 1148
HDU 4285 circuits 给你一个N*M的矩阵,矩阵有好格子和坏格子,要求你求一共有多少种情况使得K条回路包括了所有的好格子,但是回路不能嵌套. 输入:首先是一个T,表示输入实例个数.对于每个实例,第一行是N,M和K (2 输出:ans%1000000007 分析:依然是插头DP,只需要考虑当前格子的插头轮廓线状态集合. 当插头状态为112233,时,1和1,2和2,3和3可
URAL1519
code
03-03 1036
ural1519formula 1 给你一个n*m的矩阵,矩阵中有一些格子是坏的,现在要你在矩阵中画一个环,这个环要经过矩阵中所有好的格子一次,问你有多少种画法. 分析:典型的插头dp问题,详见cdq的论文>,这里我用的一般解法做的,一般解法速度没有特殊括号表示法快,但是通用性很好. AC代码:328ms #include #include #include using names
ZOJ 3213
code
03-07 1006
ZOJ 3213 Beautiful Meadow 现在有一个N*M矩阵,你走在矩阵上的好格可以获得上面的分数,坏格子不能走且分数为0.现在你可以从矩阵上的任何一个好格子出发,然后在矩阵中任何一个好格子结束,搜集分数,且每个格子只能走一次.问你最多能得到多少分. 输入:首先是一个T (1 输出:输出最大分数. 分析:增加标记位标记当前状态中独立插头已经有几个了,最多只能有2个. 如果该
FZU1977
code
03-04 926
FZU1977 Pandora adventure 依然是一个N*M的矩阵,但是矩阵中有3种格子,第一种必走的格子(必须走1次),第二种不走的格子(不能走),第三种可选格子(可以选择走还是不走),现在要你求一共有多少种方式走一个规则圈,包括了所有必走的格子,不含不走的格子,可以选择包括可选格子. 输入:首先是T (T≤100)表示实例个数.接下来每个实例第一行为N和M(1≤N, M≤12),然
zoj 1649 python
最新发布
06-05
Zoj 1649是一个未指定具体的题目编号，因为ZOJ（ZOJ Online Judge）是著名的在线算法竞赛平台，上面有数千道题目，每道题目的描述、类型和Python解决方案都有可能不同。如果你能提供完整的题目链接或者题目描述，我...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值