POJ 3133 Manhattan Wiring

最新推荐文章于 2019-10-04 03:06:40 发布
最新推荐文章于 2019-10-04 03:06:40 发布
阅读量499 收藏 1
点赞数
分类专栏： 插头DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imutzcy/article/details/25713705
版权

将格子中的两个2和两个3连起来，求经过总的格子数的总和减2.

Hint：两条路径不能交叉，有障碍格子。非障碍格子只能经过一次。

SOL：

插头记录三种状态： 0----没有插头

2----数字2

3----数字3


用四进制优于三进制。


#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>

using namespace std;

const int MAXD=15;
const int HASH=10007;
const int STATE=1000010;

int N,M;
int maze[MAXD][MAXD];//0表示障碍，1是非障碍，2和3
int code[MAXD];
//0表示没有插头,2表示和插头2相连，3表示和插头3相连

struct HASHMAP
{
    int head[HASH],next[STATE],size;
    int state[STATE];
    int dp[STATE];
    void init()
    {
        size=0;
        memset(head,-1,sizeof(head));
    }
    void push(int st,int ans)
    {
        int i,h=st%HASH;
        for(i=head[h];i!=-1;i=next[i])
          if(state[i]==st)
          {
              if(dp[i]>ans)dp[i]=ans;
              return;
          }
        state[size]=st;
        dp[size]=ans;
        next[size]=head[h];
        head[h]=size++;
    }
}hm[2];

void decode(int *code,int m,int st)//四进制
{
    int i;
    for(int i=m;i>=0;i--)
    {
        code[i]=(st&3);
        st>>=2;
    }
}

int encode(int *code,int m)
{
    int i;
    int st=0;
    for(int i=0;i<=m;i++)
    {
        st<<=2;
        st|=code[i];
    }
    return st;
}

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)
{
    int k,left,up;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        left=code[j-1];
        up=code[j];
        if(left&&up)
        {
            if(left==up)//只能是相同的插头
            {
                code[j-1]=code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
        }
        else if((left&&(!up))||((!left)&&up))//只有一个插头
        {
            int t;
            if(left)t=left;
            else t=up;//这里少写个else ,查了好久的错误
            if(maze[i][j+1]==1||maze[i][j+1]==t)//插头从右边出来
            {
                code[j-1]=0;
                code[j]=t;
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
            if(maze[i+1][j]==1||maze[i+1][j]==t)//插头从下边出来
            {
                code[j]=0;
                code[j-1]=t;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
        }
        else if(left==0&&up==0)//没有插头
        {
            code[j-1]=code[j]=0;//不加插头
            if(j==M)shift(code,M);
            hm[cur^1].push(encode(code,M),hm[cur].dp[k]);
            if(maze[i][j+1]&&maze[i+1][j])
            {
                if(maze[i][j+1]==1&&maze[i+1][j]==1)
                {
                    decode(code,M,hm[cur].state[k]);
                    code[j-1]=code[j]=2;//加2号插头
                    hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
                    //decode(code,M,hm[cur].state[k]);
                    code[j-1]=code[j]=3;//加3号插头
                    hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
                }
                else if((maze[i][j+1]==2&&maze[i+1][j]==1)||(maze[i+1][j]==2&&maze[i][j+1]==1)||(maze[i][j+1]==2&&maze[i+1][j]==2))
                {
                    decode(code,M,hm[cur].state[k]);
                    code[j-1]=code[j]=2;
                    hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
                }
                else if((maze[i][j+1]==3&&maze[i+1][j]==1)||(maze[i+1][j]==3&&maze[i][j+1]==1)||(maze[i][j+1]==3&&maze[i+1][j]==3))
                {
                    decode(code,M,hm[cur].state[k]);
                    code[j-1]=code[j]=3;
                    hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
                }
            }
        }
    }
}

void dpblock(int i,int j,int cur)
{
    int k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        if(code[j-1]!=0||code[j]!=0)continue;
        code[j-1]=code[j]=0;//不加插头
        if(j==M)shift(code,M);
        hm[cur^1].push(encode(code,M),hm[cur].dp[k]);
    }
}

void dp_2(int i,int j,int cur)
{
    int left,up,k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        left=code[j-1];
        up=code[j];
        if((left==2&&up==0)||(left==0&&up==2))
        {
            code[j-1]=code[j]=0;
            if(j==M)shift(code,M);
            hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
        }
        else if(left==0&&up==0)
        {
            if(maze[i][j+1]==1||maze[i][j+1]==2)
            {
                code[j-1]=0;
                code[j]=2;
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
            if(maze[i+1][j]==1||maze[i+1][j]==2)
            {
                code[j-1]=2;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
        }
    }
}
void dp_3(int i,int j,int cur)
{
    int left,up,k;
    for(k=0;k<hm[cur].size;k++)
    {
        decode(code,M,hm[cur].state[k]);
        left=code[j-1];
        up=code[j];
        if((left==3&&up==0)||(left==0&&up==3))
        {
            code[j-1]=code[j]=0;
            if(j==M)shift(code,M);
            hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
        }
        else if(left==0&&up==0)
        {
            if(maze[i][j+1]==1||maze[i][j+1]==3)
            {
                code[j-1]=0;
                code[j]=3;
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
            if(maze[i+1][j]==1||maze[i+1][j]==3)
            {
                code[j-1]=3;
                code[j]=0;
                if(j==M)shift(code,M);
                hm[cur^1].push(encode(code,M),hm[cur].dp[k]+1);
            }
        }
    }
}

void init()
{
    memset(maze,0,sizeof(maze));
    for(int i=1;i<=N;i++)
      for(int j=1;j<=M;j++)
      {
          scanf("%d",&maze[i][j]);
          if(maze[i][j]==0)maze[i][j]=1;
          else if(maze[i][j]==1)maze[i][j]=0;
          //两种表达方式 
          //if(maze[i][j]==1||maze[i][j]==0)maze[i][j]^=1;//0变1，1变0
      }
}

void solve()
{
    int i,j,cur=0;
    hm[cur].init();
    hm[cur].push(0,0);
    for(int i=1;i<=N;i++)
      for(int j=1;j<=M;j++)
      {
          hm[cur^1].init();
          if(maze[i][j]==0)dpblock(i,j,cur);
          else if(maze[i][j]==1)dpblank(i,j,cur);
          else if(maze[i][j]==2)dp_2(i,j,cur);
          else if(maze[i][j]==3)dp_3(i,j,cur);
          cur^=1;
      }
    int ans=0;
    for(int i=0;i<hm[cur].size;i++)
      ans+=hm[cur].dp[i];
    if(ans>0)ans-=2;
    printf("%d\n",ans);
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(scanf("%d%d",&N,&M))
    {
        if(N==0&&M==0)break;
        init();
        solve();
    }
    return 0;
}


muczzcy
关注
专栏目录
POJ_3131.zip_POJ 八数码_poj
09-20
标题中的“POJ_3131.zip_POJ 八数码_poj”指的是一个与编程竞赛网站POJ（Problem Set Algorithm）相关的项目，具体是针对3131号问题的解决方案，该问题涉及到了八数码游戏。八数码游戏，又称滑动拼图，是一个经典的...
POJ.rar_poj java_poj1048
最新发布
09-24
【标题】"POJ.rar_poj java_poj1048" 涉及的知识点主要围绕编程竞赛中的“约瑟夫环”问题，这里是一个加强版，使用Java语言进行解决。 【描述】"POJ1048，加强版的约瑟夫问题 难度中等" 提示我们，这个问题是编程...
POJ 3133 Manhattan Wiring
月下沙茶树
02-27 621
辣鸡题目，毁我青春，费我时间，害我性命。 白书上的题目，轮廓线状压DP真是无爱了。 思考半小时，代码两小时TAT，我又回忆起了NOIP上写的那个脑残状压DP了，坑爹的优化。。。。。。 不过好歹1A了是不是。 这波不亏 手算一下有11种转移。 都列出来然后就是码码码了。 MD有个转移算错了查了半小时，还顺便学了下GDB #include #include #include using
poj 3133 Manhattan Wiring
weixin_33919950的博客
12-04 83
http://poj.org/problem?id=3133 考虑插头 dp 用四进制表示一个插头的状态，0 表示没有插头，2 表示这个插头是连接两个 2 的，3 同理 然后就是大力分类讨论了 这题还是比较友善的一题，思路相对来说简单很多 我写的括号序列的方法状态是满的，数组必须开到 $ 3 ^ 9 $ 才能过 #include <cstdio> #include <cstrin...
poj3133 Manhattan Wiring
weixin_30379531的博客
02-23 90
Manhattan Wiring Time Limit:5000MS Memory Limit:65536K Total Submissions:2016 Accepted:1162 Description There is a rectangular area containingn×mcells. T...
POJ 3133 Manhattan Wiring 笔记
woniupengpeng的专栏
07-18 226
n*m矩阵，1 代表障碍物，如图，要求连线 2 与连线 3 不能有交点。求两个连线和的最小长度。
【插头DP】POJ 3133 Manhattan Wiring
10-04 98
通道：http://poj.org/problem?id=3133 题意：2条简单路径，不相交，最小权值，可选可不选，有障碍。 思路：构造2条轮廓线分辨表示两条路径即可。 代码： 1 #include <cstdio> 2 #include <cstring> 3 #include <algorithm> 4 ...
POJ 3133 Manhattan Wiring（限制匹配的插头DP）
yasolx的博客
08-02 459
Manhattan Wiring Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 1921   Accepted: 1130 Description There is a rectangular area containing n × m cells. Tw
POJ 3133 Manhattan Wiring(插头DP)
weixin_33915554的博客
01-08 88
题目链接：http://poj.org/problem?id=3133 题意：n*m的格子中有两个2和两个3，其余是空白或障碍。找出两条路径分别连接2和3，不经过障碍且不相交。使得两条路径长度和最短？ 思路：标记每个联通块是2的还是3的还是都不是。转移时分空白格子、障碍格子和2、3格子三种情况。空白格子在合并时要注意，左侧和上侧若是2或3则必须同时是2或者同时是3；2、3格子转移时，左侧和...
[插头DP] poj3133 Manhattan Wiring
CE玩家
08-10 420
还是一道插头DP 不过我的代码跑的好慢啊啊，要卡卡常才能过#include <cstdio> #include <iostream> #include <algorithm> #include <string> #include <cstring>using namespace std;const int N=20010,inf=1<<30;int n,m; int f[10][10][4][N]
POJ3133 Manhattan Wiring（难题 较为复杂）
qq_36782366的博客
07-28 378
题目链接：poj3133 参考博客：点击打开链接 现在有一个N*M（2 输入：包含多组实例。每个实例第一行为N和M，然后是数字矩阵。输入以0和0结束。 输出：输出最小的短长度，如果不存在这样的两条线，就输出0. 分析：插头DP问题，只要按常规的插头DP问题来处理即可，但是要分别特殊处理2和3格子，然后用f[]记录最小长度即可。插头只有3种，0插头（表示无），2插头和3插头。 会不会
poj2775.rar_poj_poj 27_poj27_poj2775
09-23
标签"poj poj_27 poj27 poj2775"进一步确认了这是一道关于POJ平台的编程挑战，其中"poj_27"可能是表示第27类问题或者某种分类，而"poj27"可能是对"poj2775"的简写。 压缩文件中的"www.pudn.com.txt"可能是一个链接...
poj.rar_poj
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ1753.rar_poj 1753_poj1753
09-20
【标题】"POJ1753.rar_poj 1753_poj1753" 提供的资源是关于POJ1753编程挑战的解决方案，其中包括了完整的代码实现以及实验报告。POJ（Problem Online Judge）是中国大学常用的在线编程竞赛平台，它提供了一系列的...
HDU 4285 circuits
imut zcy,I promise You.
05-13 990
插头DP。 题目要求构造出K条回路的方案数，而且不能出现环套环。 Sol：通过增加标记为来记录形成的回路数，假如不形成环的话就是在形成新的环路，此时，两边的插头个数要为偶数。 #include #include #include #include using namespace std; const int MAXD=15; const int STATE=1000010; const i
HDU 3377 Plan
imut zcy,I promise You.
05-13 778
插头DP。 从左上角到右下角，每个格子都有Val，每个格子只能经过一次，可以不经过，求最大的分数之和。 #include #include #include #include using namespace std; const int MAXD=15; const int HASH=10007; const int STATE=1000010; int N,M; int maz
HDU 1693 Eat the Trees
imut zcy,I promise You.
05-13 728
插头DP，多条回路求回路数。 可以当作模版来记。注重理解轮廓线。 #include #include #include #include using namespace std; const int HASH=10007; const int STATE=5000; //状态数 const int MAXD=15; int code[MAXD],maze[MAXD][MAXD];
跟着Kuangbin学插头DP
imut zcy,I promise You.
05-13 567
看完了Bin个推荐的Blog和论文，再结合Bin
POJ编程题解资源集合
"这些题目是来自POJ (Programming Online Judge) 的一系列算法练习题，涵盖了基础到中等难度的编程问题。题目涉及了各种算法和数据结构，包括但不限于数学计算、字符串处理、逻辑推理、递归、动态规划、位运算等。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值