URAL 1519 Formula 1 dp(插头)

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

这里写图片描述

题意：

给出n*m的方格，有些格子不能铺线，其它格子必须铺，形成一个闭合回路。问有多少种铺法？

解:

括号表示法：

4进制状压表示，用m+1位表示轮廓线上的m个位置的情况。

0表示没有插头与线相交，1表示插头’左’,2表示插头’右’。类似括号匹配。

重要的一点是轮廓线上方的线路不能相交。

转移：

1.当前格上左无插头，则该格下右建插头，新的连通分量。

2.上或左有插头，必连下或右，仅一个。

3.上左均有插头，考虑连通分量的消除。

轮廓线上需要关心的只是哪些线上面有插头，

1情况是起点，3情况包含了终点，但不仅仅是终点。

固定了起点和终点，所以能保证只有两条线，只要转移时能保证这两条线

不相交并且遍历完所有无障碍格子即可。(保证两线从起点出发，到终点汇

合)

到行末时，状态需要*4（因为是四进制），然后可以考虑CLEAR(m+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<ll, ll> pll;
const int INF =0x3f3f3f3f;
const int maxn=12    ;
const int maxV=1e6    ;
const int mod=19993;
int n,m,nn,mm;
int a[maxn+10][maxn+10];
int cur;
int state[2][maxV];
ll sum[2][maxV];
int tot[2],HASH[maxV];
int pre[maxn+10];

void pr()
{
    pre[0]=1;
    for1(i,maxn+3)
    {
        pre[i]=ysk((i<<1));
    }
}

void insert(int S,ll nu)
{
    int p=S%mod;
    while(~HASH[p])
    {
        if(state[cur][HASH[p]]==S)
        {
            sum[cur][HASH[p]]+=nu;
            return;
        }
        if(++p==mod) p=0;
    }
    HASH[p]=tot[cur];
    state[cur][tot[cur]]=S;sum[cur][tot[cur]++]=nu;
}

void show(ll s)
{
    cout<<"show"<<s<<endl;

    for(int i=0;i<=m;i++)
    {
       ll x=s/pre[i];
       x%=4;
       cout<<x;
    }
    cout<<endl;
}
void solve()
{
    ll ans=0;
    cur=0;
    mem(state[cur],0);
    mem(sum[cur],0);
    tot[cur]=0;
    mem(HASH,-1);
    tot[cur]=1;sum[cur][0]=1;
    state[cur][0]=0;

    for1(i,n)
    {
        for1(j,m)
        {
            cur^=1;
            mem(state[cur],0);
            mem(sum[cur],0);
            tot[cur]=0;
            mem(HASH,-1);
//            printf("i=%d,j=%d,tot^1=%d\n",i,j,tot[cur^1]);
            for0(k,tot[1^cur])
            {
                int S=state[1^cur][k];
                ll nu=sum[1^cur][k];
                int p=(S/pre[j-1])%4;
                int q=(S/pre[j])%4;
//                printf("p=%d,q=%d,S=%lld\n",p,q,S);
//                show(S);



                if(!a[i][j])
                {
                     if(!p&&!q) insert(S,nu);
                     continue;
                }

                int S2;
                if(!p&&!q)
                {
                    if(a[i][j+1]&&a[i+1][j])
                    {
                       S2=S+pre[j-1]+2*pre[j] ;
                       insert(S2,nu);
                    }
                }
                else if(!p&&q)
                {
                   if(a[i][j+1]) insert(S,nu);
                   if(a[i+1][j])
                   {
                      S2=S-q*pre[j]+q*pre[j-1];
                      insert(S2,nu);
                   }

                }
                else if(p&&!q)
                {
                    if(a[i+1][j])  insert(S,nu);
                    if(a[i][j+1])
                    {
                        S2=S-p*pre[j-1]+p*pre[j];

                        insert(S2,nu);
                    }

                }
                else if(p==1&&q==1)
                {
                    int cnt=1;
                   for(int pp=j+1;pp<=m;pp++)
                   {
                       if( (S/pre[pp])%4 ==1  )  cnt++;
                       if( (S/pre[pp])%4 ==2  )  cnt--;
                       if(cnt==0)
                       {
                           S2=S-2*pre[pp]+1*pre[pp];
                           break;
                       }
                   }
                   S2=S2-pre[j-1]-pre[j];
                   insert(S2,nu);
                }
                else if(p==2&&q==2)
                {
                   int cnt=1;
                   for(int pp=j-2;pp>=0;pp--)
                   {
                       if( (S/pre[pp])%4 ==1  )  cnt--;
                       if( (S/pre[pp])%4 ==2  )  cnt++;
                       if(cnt==0)
                       {
                           S2=S+2*pre[pp]-1*pre[pp];
                           break;
                       }
                   }
                   S2=S2-2*pre[j-1]-2*pre[j];
                   insert(S2,nu);

                }
                else if(p==2&&q==1)
                {
                     S2=S-2*pre[j-1]-pre[j];
                     insert(S2,nu);
                }
                else if(p==1&&q==2)
                {
                    if(i==nn&&j==mm) ans+=nu;
                }


              }

        }
         for(int k=0;k<tot[cur];k++)
         {
             state[cur][k]<<=2;
             while(state[cur][k]>=pre[m+1]) state[cur][k]-=pre[m+1];
         }
    }
    cout<<ans<<endl;

}
int main()
{
   std::ios::sync_with_stdio(false);
   char ch;
   pr();
   while(cin>>n>>m)
   {
       mem(a,0);
       for1(i,n)
       {
           for1(j,m)
           {
               cin>>ch;
               a[i][j]=ch=='.'?1:0;
               if(a[i][j])
               {
                   nn=i,mm=j;
               }
           }
       }
       solve();
   }
   return 0;
}
/*
4 4
**..
....
....
....
*/
/*
1 4
....


1 1
.

1 2
..
2 2
..
..
*/
最小表示法：

8进制表示，每一个连通分量用数字表示，0表示没有插头。
因为只能有一条线，即轮廓线上方不能分叉，而且轮廓线最多13格，其中有一条是竖线，，可以发现最多到数字6。
可以用7进制表示，但是8进制能用位运算，更快。

对于当前格子，设p=左插头编号，q=上插头编号，如果为0证明没有插头。

1)
如果p==0&&q==0 ,那么新建连通分量，轮廓线上变为下插头+右插头。

2)
如果!p&&q||p&&!q ,考虑右插头或者下插头，不能同时有。

3)
如果p&&q ,

如果p==q，此时只能在最后一个非障碍格子才能进行状态转移。

否则将左插头的连通分量改为上插头编号。

对于情况3)，如果是最后一个非障碍格子，只有当上左插头的编号相同时才纳入ans的计算。

这个题目要注意没有非障碍格子的情况。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#define for0(a, n) for (int (a) = 0; (a) < (n); (a)++)
#define for1(a, n) for (int (a) = 1; (a) <= (n); (a)++)
#define mem(a,x)  memset(a,x,sizeof a)
using namespace std;
const int maxn=12;
const int mod=19993;
typedef long long ll;
typedef pair<ll ,ll>pll;
int cur,nn,mm,n,m,a[maxn+3][maxn+3];
ll ans;
struct Hash
{
    vector<pll>G[mod+3];
    void init()  { for0(i,mod) G[i].clear();}
    void insert(ll s,ll val)
    {
        int p=s%mod;
        for0(i,G[p].size())
        {
            if(G[p][i].first==s)  {
                G[p][i].second+=val;return;
            }
        }
        G[p].push_back(make_pair(s,val));
    }

}hashmap[2];

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

}code;


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

void updateBlank(int x,int y,ll state,ll val)
{

        const int p=code.bit[y-1];
        const int q=code.bit[y];
        if(!p&&!q)
        {
            if(a[x][y+1]&&a[x+1][y])
            {
                code.bit[y-1]=code.bit[y]=code.tot++;
                code.normalize();
                hashmap[cur].insert(code.s,val);
            }
        }
        else  if(p&&!q||!p&&q)
        {
            int t=p+q;
            if(a[x][y+1])
            {
                code.bit[y-1]=0,code.bit[y]=t;
                code.normalize();
                hashmap[cur].insert(code.s,val);
            }
            if(a[x+1][y])
            {
                code.bit[y-1]=t,code.bit[y]=0;
                if(y==m)  code.shift();
                code.normalize();
                hashmap[cur].insert(code.s,val);
            }
        }
        else
        {
            if(p==q)
            {
                if(x==nn&&y==mm)
                {
                    code.bit[y-1]=code.bit[y]=0;
                    if(y==m)  code.shift();
                    code.normalize();
                    hashmap[cur].insert(code.s,val);
                    ans+=val;
                }
            }
            else
            {
                code.color(p,q);
                code.bit[y-1]=code.bit[y]=0;
                if(y==m)  code.shift();
                code.normalize();
                hashmap[cur].insert(code.s,val);
            }
        }

}
void solve()
{
    ans=cur=0;
    hashmap[cur].init();
    hashmap[cur].insert(0,1);
    for1(i,n)
    {
        for1(j,m)
        {
            cur^=1;hashmap[cur].init();
            for0(k,mod) for0(l,hashmap[cur^1].G[k].size()){
             pll now=hashmap[cur^1].G[k][l];
             ll state=now.first,val=now.second;
             code.init(state);
            if(a[i][j])  updateBlank(i,j,state,val);
            else   updateBlock(i,j,state,val);
            }
        }
    }
    cout<<ans<<endl;
}
int main()
{
    while(cin>>n>>m)
    {
       mem(a,0);nn=mm=-1;
       char ch;
       for1(i,n) for1(j,m) {
           cin>>ch;
           if(ch=='.')  {
                a[i][j]=1;
                nn=i,mm=j;
           }
       }
       if(nn==-1) {
        puts("0");
        continue;
       }
       solve();
    }
    return 0;
}
/*
2 2
..
..
2 3
...
...
3 2
..
..
..
12 12
............
............
............
............
............
............
............
............
............
............
............
............
*/
PoemK
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Ural
10-25
Ural
【学习笔记】简单的连通性状压DP——插头DP（不学以为是天书）
01-02 3913
不学不会，一学还是不会。
dp-插头dp
w75779的博客
09-25 857
插头dp 真的烦
插头dp ——从入门到跳楼
热门推荐
litble的成(tui)长(fei)史
02-25 2万+
课前预习 Q:什么题目使用插头dp? A:关键词：超小数据范围，网格图，连通性。 Q:什么是“插头”？ A:一个格子通过某些方向与另一个格子相连，这些连接的位置叫做“插头”。形象地理解，网格图上每一个格子是一块拼图，那么两块拼图的接口就叫做“插头”。 Q:什么是“轮廓线”？ A:我们在网格图中选择一个关键格子（图中黄色格子）(i,j)(i,j)(i,j)，轮廓线就是蓝色的线。 ...
好学易懂 从零开始的插头DP（二）
hollyidyllic的博客
11-23 586
好学易懂 从零开始的插头DP（二） 前情提要 上篇文章里，我们解决了一个例题，了解了，从回路模型转换到插头模型的一些性质和优点。知道了只要按规则放置插头，就可以保证都是闭合回路。现在，让我们对例题做一些改变，之前是可以多个闭合回路，如果现在要求只能有一条闭合回路呢？ 例题的变化 洛谷P5056 【模板】插头DP 给出 n×m 的方格，有些格子不能铺线，其它格子必须铺，形成一个闭合回路。问有多少种铺法？(1<=n,m<=12)(1<=n,m<=12)(1<=n,m<=12)
插头dp。
hungry1234的博客
03-16 478
插头dp解决网格问题 轮廓线 就是格子的边 每次维护一个格子周围的状态，使之能够不重不漏的表示所有格子的状态 吃树 题意：求若干回路覆盖所有格子的方案数 枚举每个格子，维护包围着一个格子的轮廓线 对于每一行，已经处理过的格子轮廓线是格子的底边，要处理的格子由一条向左和向下（左边和顶边）的轮廓线包含，其他未处理的格子的轮廓线就是格子的顶边 就是这样 二进制压位，用1表示这条轮廓线有连向此点的边，0表示没有 分类讨论一个格子左方和上方有没有边与这个格子连接进行转移： 若这个格子是障.
Ural URAL 解题思路
01-11
Ural解题思路 Ural解题思路 Ural解题思路 Ural解题思路
ural
03-17
乌拉尔
Ural 1238 源代码
12-19
Ural 1238 源代码 涉及算法（动态规划、贪心、DFS）
Ural-开源
04-27
基于张量类模板的线性代数C ++库，可用于表示等级0的张量，标量向量，1的向量，2的矩阵，3的等级3的张量等。它还包括BLAS和LAPACK子例程的接口。
NOIP基础-插头DP课件
12-15
NOIP基础内容学习-插头DP的精品课件，金牌选手打造，冲击NOIP必备
动态规划之插头DP入门
qxAi的博客
03-20 8766
基于联通性的状态压缩动态规划是一类很典型的状态压缩动态规划问题，因为其压缩的本质并不像是普通的状态压缩动态规划那样用0或者1来表示未使用、使用两种状态，而是使用数字来表示类似插头的状态，因此，它又被称作插头DP。 插头DP本质上是一类状态压缩DP，因此，依然避免不了其指数级别的算法复杂度，即便如此，它依然要比普通的搜索算法快很多。 【例】Postal Vans（USACO training
【连通性状态压缩DP】URAL1519
氧化钠的博客
02-07 486
URAL1519（vjudge） 题意：给出一个n*m的矩阵，有的是空白格，有的是障碍格。你的任务是用一条回路来遍历整个矩阵的空白格，不能经过障碍格。统计这样的回路数量。题解： 这道题和hdu1693唯一的不同，就是它限定了只有一条回路（但却恶心了好多倍）。一条回路，即意味着每个插头属于同一个联通块。所以在hdu1693的基础上，我们还要确定每个插头的连通性。这里仅介绍编码复杂度小，耗时较多的方
【Ural】1519. Formula 1
01-15 184
http://acm.timus.ru/problem.aspx?space=1&num=1519 题意：给一个n×m的棋盘，其中'.'是空白，'*'是障碍，求经过所有点的哈密顿回路的数目。（n,m<=12） #include <bits/stdc++.h> using namespace std; typedef long long ll; ...
插头dp
shi_zi_183的博客
09-14 734
插头dp 之前在讲状压dp时还没有了解过插头dp，但状压的最后一道例题已经和插头dp很像了，这节就来解决一个插头dp的入门问题。 插头dp学习之前需要掌握或了解的东西：状压dp，哈希表，状压用来压缩一些局面，但可能出现的情况很多导致状压后的数很大，这时候就可以使用哈希表来仅存放已出现的局面，避免开辟太大的数组。 插头dp有几个关键词，当关键词出现时可以向这方面考虑：超小数据范围，网格图，连通性。 还需要理解一些抽象的定义： 插头 一个格子以某种方式向另一个格子相连，相连的位置叫插头，具体的类似拼图的凹槽与凸
ural1519
weixin_30239339的博客
06-05 123
https://vjudge.net/problem/URAL-1519 插头dp。。。 终于A掉了。。。抄了一个板子。。。 看那个ccy大神的博客 写的非常好。。。 讲几个问题：插头就是线穿过格子的边缘 左插头就是竖着的轮廓线左边 右插头就是竖着的轮廓线右边。。。我好想没用到这个概念。。。 然后就是各种分类讨论。。。 dp初值：dp[0][0]=1 第0行状态为0的方案数为...
插头DP学习笔记
weixin_34208185的博客
09-18 532
hhh还是滚去学了插头DP。。。 这玩意理解起来其实并不是听说的那么困难。（那是因为你只写了板子QAQ 我太菜了所以可能写了一堆锅，所以哪位爸爸发现了错误指出来就好。谢谢orz！ 基本概念 Q：插头DP是啥？ A：基于连通性状态压缩的动态规划 Q：它可以干嘛？ A：不是说了嘛...基于连通性状态压缩的动态规划嘛分为两类，骨牌覆盖&线段覆盖 Q：啥时候用？ A：网格，数据范...
ural 1519 Formula 1(轮廓线|插头DP|括号配对)
GODSPEED
09-09 1156
题意：给你一个m * n的棋盘，有的格子是障碍，问共有多少条回路使得经过每个非障碍格子恰好一次．m, n ≤ 12。 如图，m = n = 4，(1, 1), (1, 2)是障碍，共有2条满足要求的回路． Formula 1" alt="【动态规划】Ural1519 Formula 1" src="http://s4.sinaimg.cn/bmiddle/51cea404x7abee2b588
URAL - 1519 ：Formula 1
Mitsuha_的博客
09-03 392
URAL - 1519 ：Formula 1 Who will be smart enough to draw a plan of the circuit and keep the city from inevitable disgrace? Of course, only true professionals - battle-hardened programmers from the first team of local technical university!.. But our heroes w
Ural 1029 Ministry 题解
最新发布
05-31
Ural 1029 Ministry 是一道比较简单的贪心题目，以下是一种可行的思路： 首先，我们可以考虑对所有的数字进行排序，然后从小到大依次遍历这些数字。对于每一个数字，我们需要判断它是否可以被当前的部门所处理。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值