poj 1739 Tony's Tour 插头dp

最新推荐文章于 2020-08-27 12:21:46 发布
最新推荐文章于 2020-08-27 12:21:46 发布
阅读量460 收藏 1
点赞数
分类专栏： ACM_动态规划 轮廓线&&插头dp 文章标签： dp poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yskyskyer123/article/details/52287591
版权

题目链接

题意：

障碍格子不能走，非障碍格子必须遍历，
要求从左下角走到右下角，问方案数。

解:

1.添加两行,转化为求回路：

.####.
… … 

#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;

#define all(x) (x).begin(), (x).end()
#define for0(a, n) for (int (a) = 0; (a) < (n); (a)++)
#define for1(a, n) for (int (a) = 1; (a) <= (n); (a)++)
#define mes(a,x,s)  memset(a,x,(s)*sizeof a[0])
#define mem(a,x)  memset(a,x,sizeof a)
#define ysk(x)  (1<<(x))
typedef long long ll;
typedef pair<int, int> pii;
const int INF =0x3f3f3f3f;
const int maxn=  8  ;
const int mod=19993;
const int N= 300000  ;
int n,m,cur;
struct pll
{
  ll first;ll second;
};
int a[maxn+5][maxn+5];
struct Hashmap
{
    pll e[N];
    int fir[mod+3],nex[N],nedge;
    void init()
    {
        nedge=0;
        mem(fir,-1);
    }
    void insert(ll state,ll val)
    {
        int p=state%mod;
        for(int i=fir[p];~i;i=nex[i])
        {
            if(state==e[i].first)
            {
                e[i].second+=val;
                return;
            }
        }
        e[nedge].first=state,e[nedge].second=val;
        nex[nedge]=fir[p];
        fir[p]=nedge++;
    }


}ha[2];


struct Code
{
   int tot,bit[maxn+3],ch[maxn+3];
   ll s;
   void decode(int x)
   {
       tot=0;
       for(int i=0;i<=m;i++)
       {
           bit[i]=x&7;
           tot=max(tot,bit[i]);
           x>>=3;
       }
       tot++;
    }
    ll normalize()
    {
        mem(ch,-1);ch[0]=0;tot=1;
        s=0;
        for(int i=m;i>=0;i--)
        {
            if(ch[bit[i]]==-1) ch[bit[i]]=tot++;
            bit[i]=ch[bit[i]];
            s=(s<<3)|bit[i];
        }
        return s;
    }
    void shift()
    {
        for(int i=m;i>0;i--)  bit[i]=bit[i-1];
        bit[0]=0;
    }
    void color(int a,int b)//a to b
    {
        for0(i,m+1) if(bit[i]==a)
        {
            bit[i]=b;
        }
    }
}code;

void dpBlock(int x,int y,ll state,ll val)
{
    if(y==m) code.shift();
    ha[cur].insert(code.normalize(),val);
}
void dpBlank(int x,int y,ll state,ll val)
{
    const int p=code.bit[y-1],q=code.bit[y];
    if(p&&q)
    {
        if(p==q)
        {
            if(x==n&&y==m)
            {
                code.bit[y-1]=code.bit[y]=0;
                code.shift();
                ha[cur].insert(code.normalize(),val);
            }
        }
        else
        {
            code.color(p,q);
            code.bit[y-1]=code.bit[y]=0;
            if(y==m) code.shift();
            ha[cur].insert(code.normalize(),val);
        }
        return;
    }
    if(!p&&!q)
    {
        if(a[x][y+1]&&a[x+1][y])
        {
            code.bit[y-1]=code.bit[y]=code.tot;
            ha[cur].insert(code.normalize(),val);
        }
        return;

    }
    int t=p+q;
    if(a[x][y+1])
    {
        code.bit[y-1]=0,code.bit[y]=t;
        ha[cur].insert(code.normalize(),val);
    }
    if(a[x+1][y])
    {
        code.bit[y-1]=t,code.bit[y]=0;
        if(y==m)  code.shift();
        ha[cur].insert(code.normalize(),val);
    }


}

void solve()
{
    cur=0;
    ha[cur].init();
    ha[cur].insert(0,1);
    for1(i,n)  for1(j,m)
    {
       cur^=1;
       ha[cur].init();
       for0(k,mod)  for(int l=ha[cur^1].fir[k];~l;l=ha[1^cur].nex[l])
       {
          pll now=ha[cur^1].e[l];
          ll state=now.first,val=now.second;
          code.decode(state);
//          printf("i=%d,j=%d,state=%lld,val=%lld\n",i,j,state,val);
          if(!a[i][j])  dpBlock(i,j,state,val);
          else   dpBlank(i,j,state,val);
       }
    }
    ll ans=0;
    for0(k,mod )  for(int l=ha[cur].fir[k];~l;l=ha[cur].nex[l])
    {
        ans+=ha[cur].e[l].second;
    }
    cout<<ans<<endl;
}
int main()
{
   std::ios::sync_with_stdio(false);
   while(cin>>n>>m&&(n||m))
   {
       mem(a,0);char ch;
       for1(i,n) for1(j,m) {cin>>ch;if(ch=='.')  a[i][j]=1;}
       if(!a[n][1]||!a[n][m])  {cout<<0<<endl;continue;}
       if(n==1&&m==1)  {cout<<1<<endl;continue;}
       ++n;
       a[n][1]=a[n][m]=1;
       ++n;
       for1(j,m) a[n][j]=1;
       solve();
   }
   return 0;
}
2.在起点与终点做特殊处理
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;

#define all(x) (x).begin(), (x).end()
#define for0(a, n) for (int (a) = 0; (a) < (n); (a)++)
#define for1(a, n) for (int (a) = 1; (a) <= (n); (a)++)
#define mes(a,x,s)  memset(a,x,(s)*sizeof a[0])
#define mem(a,x)  memset(a,x,sizeof a)
#define ysk(x)  (1<<(x))
typedef long long ll;
typedef pair<int, int> pii;
const int INF =0x3f3f3f3f;
const int maxn=  8  ;
const int mod=19993;
const int N= 300000  ;
int n,m,cur;
struct pll
{
  ll first;ll second;
};
int a[maxn+5][maxn+5];
struct Hashmap
{
    pll e[N];
    int fir[mod+3],nex[N],nedge;
    void init()
    {
        nedge=0;
        mem(fir,-1);
    }
    void insert(ll state,ll val)
    {
        int p=state%mod;
        for(int i=fir[p];~i;i=nex[i])
        {
            if(state==e[i].first)
            {
                e[i].second+=val;
                return;
            }
        }
        e[nedge].first=state,e[nedge].second=val;
        nex[nedge]=fir[p];
        fir[p]=nedge++;
    }


}ha[2];


struct Code
{
   int tot,bit[maxn+3],ch[maxn+3];
   ll s;
   void decode(int x)
   {
       tot=0;
       for(int i=0;i<=m;i++)
       {
           bit[i]=x&7;
           tot=max(tot,bit[i]);
           x>>=3;
       }
       tot++;
    }
    ll normalize()
    {
        mem(ch,-1);ch[0]=0;tot=1;
        s=0;
        for(int i=m;i>=0;i--)
        {
            if(ch[bit[i]]==-1) ch[bit[i]]=tot++;
            bit[i]=ch[bit[i]];
            s=(s<<3)|bit[i];
        }
        return s;
    }
    void shift()
    {
        for(int i=m;i>0;i--)  bit[i]=bit[i-1];
        bit[0]=0;
    }
    void color(int a,int b)//a to b
    {
        for0(i,m+1) if(bit[i]==a)
        {
            bit[i]=b;
        }
    }
}code;

void dpBlock(int x,int y,ll state,ll val)
{
    if(y==m) code.shift();
    ha[cur].insert(code.normalize(),val);
}

void dpSE(int x,int y,ll state,ll val)
{
    const int p=code.bit[y-1],q=code.bit[y];
    if(p&&q) return;
    if(!p&&!q)
    {
        if(a[x][y+1])
        {
            code.bit[y-1]=0,code.bit[y]=code.tot;
            ha[cur].insert(code.normalize(),val);
        }
    }
    int t=p+q;
    code.bit[y-1]=code.bit[y]=0;
    if(y==m) code.shift();
    ha[cur].insert(code.normalize(),val);
}
void dpBlank(int x,int y,ll state,ll val)
{
    const int p=code.bit[y-1],q=code.bit[y];
    if(p&&q)
    {
        if(p==q)
        {
            if(x==n&&y==m)
            {
                code.bit[y-1]=code.bit[y]=0;
                code.shift();
                ha[cur].insert(code.normalize(),val);
            }
        }
        else
        {
            code.color(p,q);
            code.bit[y-1]=code.bit[y]=0;
            if(y==m) code.shift();
            ha[cur].insert(code.normalize(),val);
        }
        return;
    }
    if(!p&&!q)
    {
        if(a[x][y+1]&&a[x+1][y])
        {
            code.bit[y-1]=code.bit[y]=code.tot;
            ha[cur].insert(code.normalize(),val);
        }
        return;

    }
    int t=p+q;
    if(a[x][y+1])
    {
        code.bit[y-1]=0,code.bit[y]=t;
        ha[cur].insert(code.normalize(),val);
    }
    if(a[x+1][y])
    {
        code.bit[y-1]=t,code.bit[y]=0;
        if(y==m)  code.shift();
        ha[cur].insert(code.normalize(),val);
    }


}

void solve()
{
    cur=0;
    ha[cur].init();
    ha[cur].insert(0,1);
    for1(i,n)  for1(j,m)
    {
       cur^=1;
       ha[cur].init();
       for0(k,mod)  for(int l=ha[cur^1].fir[k];~l;l=ha[1^cur].nex[l])
       {
          pll now=ha[cur^1].e[l];
          ll state=now.first,val=now.second;
          code.decode(state);
//          printf("i=%d,j=%d,state=%lld,val=%lld\n",i,j,state,val);
          if(!a[i][j])  dpBlock(i,j,state,val);
          else  if(i==n&&j==1||i==n&&j==m)  dpSE(i,j,state,val);
          else dpBlank(i,j,state,val);
       }
    }
    ll ans=0;
    for0(k,mod )  for(int l=ha[cur].fir[k];~l;l=ha[cur].nex[l])
    {
        ans+=ha[cur].e[l].second;
    }
    cout<<ans<<endl;
}
int main()
{
   std::ios::sync_with_stdio(false);
   while(cin>>n>>m&&(n||m))
   {
       mem(a,0);char ch;
       for1(i,n) for1(j,m) {cin>>ch;if(ch=='.')  a[i][j]=1;}
       if(!a[n][1]||!a[n][m])  {cout<<0<<endl;continue;}
       if(n==1&&m==1)  {cout<<1<<endl;continue;}
       solve();
   }
   return 0;
}
PoemK
关注
专栏目录
POJ-2411-Mondriaan's Dream-轮廓线dp（插头dp）
lyc1635566ty的博客
08-09 976
题意:在n*m的方格里铺1*2的骨牌，有多少种可能，首先可以排除一些特殊情况，n*m是奇数，就是0 n或m是1就是1（已经排除n*m的情况）。然后就和我之前写的hdu1992的插头dp一样 #include #include #include #include #include using namespace std; long long dp[15][4444]; int m; void d
poj 2411（插头DP 简单题）
志当存高远
05-17 3207
Mondriaan's DreamTime Limit: 3000MS Memory Limit: 65536K Total Submissions: 5930 Accepted: 3414 Description Squares and rectangles fascinated the famous Dutch painter Piet Mondriaan. One night,
POJ1739
code
03-05 908
POJ1739 Tony's Tour 现在有一个N*M(1 输入：输入包含多组实例。每个实例的第一行为N和M，接下来是一个N*M的字符矩阵，其中‘#’表示障碍格，‘.‘表示好格。以一行0 0表示输入结束。 输出：输出有多少种行走方法。 分析：插头DP问题，且和HDU3377很类似： http://blog.csdn.net/u013480600/article/details/2047
POJ 1739
weixin_30915951的博客
08-15 79
楼教主男人八题之一。。。 题目大意： 求从左下角经过所有非障碍点一次到达右下角的方案数 这里不是求回路，但是我们可以考虑，在最下面一行再增加一行，那么就可以当做求此时左下角到右下角的回路总数，那么就转化成了陈丹琦论文的URAL1519的 方法了 但是最后一行添加的格子必须是最后一条直线跑的，也就是除了左下角和右下角中间的点只能有水平方向上的插头 1 #incl...
POJ 1739 Tony's Tour
Rayment的博客
08-23 176
珍惜生命，远离插头DP。
LichAmnesia#LichBlogPost#POJ 1205 Water Treatment Plants (DP+高精度
07-25
1.把自己的污水排到河里V 2.把自己的污水送到右边> 3.把自己的污水送到左边
poj 2411| 插头dp
heheda_is_an_OIer的博客
11-16 553
经典题： 用1*2的木板铺满n*m的矩形的方案数。做一下插头dp的模板。0表示这个位置不可以放木板（也就是已经放上了木板），1表示这个位置可以放木板（也就是没放木板）。转移有两种1.当前位置上方的格子如果没放，那么在这个格子放竖着的，如果放了，什么也不放2.当前位置上方放了，左面没放，那么可以放一个横着的。//别看代码长，大部分都是哈希表（虽然这道题用不到，以后呢？）#include#includ
POJ1739 Tony's Tour
qq_36782366的博客
07-28 574
题目链接:poj1739 题目大意： 现在有一个N*M(1 输入：输入包含多组实例。每个实例的第一行为N和M，接下来是一个N*M的字符矩阵，其中‘#’表示障碍格，‘.‘表示好格。以一行0 0表示输入结束。 输出：输出有多少种行走方法。 分析：插头DP问题，且和HDU3377很类似： hdu3377博客题解 既然从左下角到右下角找一条经过所有点的路，那么我们在最后一行后面再加一行全
poj 1739（男人八题之插头DP）
志当存高远
06-08 1864
Tony's Tour Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 1680   Accepted: 751 Description A square township has been divided up into n*m(n rows and m column
poj1739 Tony‘s Tour
binarycopycode
08-27 162
http://poj.org/problem?id=1739 普通通路问题，左下角走到右下角，那么只要在上面加两层壳，一层全不可走，一层全可走，那么总左下角走到右下角是一条路径且他和从外面这层壳的唯一路径走形成了一条回路，问题就转换成了直接求回路，就等同于模板题了 https://blog.csdn.net/liufengwei1/article/details/108114948 #include<cstdio> using namespace std; typedef long lo
【连通性状态压缩DP】poj1739
Evil.livE
07-31 4046
<br />极其恶心的一道状态压缩dp，很多细节的地方想得我头昏脑胀，做这道题差不多花了整整一天的时间吧（调到凌晨6.00），想啊想，草稿纸都花了几十张，方法和标准做法有点不一样，和cdq2008年论文中提到的方法差不多。<br /> <br />首先这道题是要我们求从一个图的左下角至右下角的哈密顿路径的条数，因为起点和终点确定了，所以可以转化为求哈密顿回路，默认左下角和右下角的方块已经连通就可以了。<br /> <br />关于状态的设计也是参考cdq2008年论文里介绍的‘插头’和‘轮廓线’的方法：<b
poj 1739 Tony's Tour(插头dp)
ACM之梦
01-30 576
题意： 给出地图，起点是(N,1),终点是(N,M),有障碍物，求有多少种方案能从起点到终点。 题解： 非环形的插头dp，特判一些起点和终点的dp，还要注意一点，从上往下dp的时候因为起点是左下角，所以不存在不建立新插头的方案！不然未走的空格子就被计算成了路径，反而增加累赘的方案数。 #include #include #include #include #include #inc
poj 1739 插头DP
马德里小铁匠的铁匠铺
04-16 734
和上一题很像，只需要增加两行就行。。。
POJ-1739-插头dp
walk_up的专栏
07-07 804
int dp[10][10][19690]; //传说中的三进制 int bit[]={1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683}; char ok[13][13]; int st[1000][10], go[19900], p[900][10], slack[10]; int k, num, tot; int main() { int n
【插头DP】 POJ 1739 Tony's Tour
10-04 110
通道：http://poj.org/problem?id=1739 题意：左下角走到右下角路径数，单回路。做法就是我们新添2行后寻找回路就可以啦 。 代码： 1 #include <cstdio> 2 #include <cstring> 3 #include <algorithm> 4 5 using na...
POJ 1739 Tony's Tour——插头dp
hao_zong_yin的博客
05-29 237
#include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;iostream&gt; #include &lt;algorithm&gt; using namespace std; const int maxn = 15; const int seed = 2e5 + 7; typedef long long ll; char ch...
插头DP模板：哈密顿回路解析
本模板针对的是POJ2064和HDU1964这两个问题，它们都涉及到插头DP和哈密顿回路。代码定义了一个`Node`结构体，存储了四个整型变量`l`, `r`, `u`, `b`，可能对应于图中某个节点的上下左右四个方向。同时，还定义了一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值