FZU1977

最新推荐文章于 2018-03-26 18:25:00 发布

focus_best

最新推荐文章于 2018-03-26 18:25:00 发布

阅读量937

点赞数

分类专栏： ACM--题解汇总 ACM--插头DP 文章标签： ACM

本文链接：https://blog.csdn.net/u013480600/article/details/20413043

版权

ACM--题解汇总同时被 3 个专栏收录

685 篇文章 11 订阅

订阅专栏

★★★

112 篇文章 0 订阅

订阅专栏

ACM--插头DP

11 篇文章 0 订阅

订阅专栏

FZU1977 Pandora adventure

依然是一个N*M的矩阵,但是矩阵中有3种格子,第一种必走的格子(必须走1次),第二种不走的格子(不能走),第三种可选格子(可以选择走还是不走),现在要你求一共有多少种方式走一个规则圈,包括了所有必走的格子,不含不走的格子,可以选择包括可选格子.

输入:首先是T (T≤100)表示实例个数.接下来每个实例第一行为N和M(1≤N, M≤12),然后是一个字符矩阵O代表必走,X代表不走,*代表可选.

输出:以 Case 1: 10 形式输出结果.保证结果在一个64位有符号整数范围内.

分析:插头DP,但是有3种格子,其中一种是可选走还是不走的格子.可以这么理解,在决策的时候必走的格子就必须走用DPblank处理,不走的格子就必须用DPblock处理,可选的格子既可以DPblank又可以DPblock处理.此题只能有一个圈.

该题和以前的题目有个不同，比如011022这个轮廓线插头状态出现时，当前处理的格子的左插头和上插头为1和1：

在以前只有好格和坏格的情况下，那么由于这个格子不是终结格子（如果这个格子是终结格子，那么它后面的都应该是坏格子，所以它后面的22插头状态不可能会出现）所以不能连接他们，自然就不能用sum+=num，即不能把他归结到终结状态的总数中去。

但是在这个情况下，当前处理的格子是最后一个必走格，但是他后面还有3个可选格子，所以当前状态下它后面还有插头，但是它已经是最后一个必走的格子了，此时是不是一定可以用sum+=num呢？不行，还要看下一当前处理的轮廓线中是不是还有其他的连通分量，其实模板就应该这么写的，终结状态是最后一个可行格子且code中除了0只有1种连通分量，这种才是终结状态。

AC代码：453ms

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=100000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;
const int MAXD=15;
int N,M;
int ex,ey;//最后一个好格的坐标
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个状态
    long long 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(long long st, long long num)
    {
        long long 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,long long st)//st->code
{
    for(int i=M; i>=0; i--)
    {
        code[i]=st&7;
        st>>=3;
    }
}
long long encode(int *code)//code->st
{
    int ch[MAXD];
    memset(ch,-1,sizeof(ch));
    ch[0]=0;
    int cnt=1;
    long long st=0;
    for(int i=0; i<=M; i++)
    {
        if( ch[code[i]]==-1 ) ch[code[i]]= cnt++;
        code[i]=ch[code[i]];
        st<<=3;
        st|=code[i];
    }
    return st;
}
void shift(int *code)//处理完了一行的最后一列,将code整体右移一位,首位添0
{
    for(int i=M; i>=1; i--)
        code[i]=code[i-1];
    code[0]=0;
}
void dpblock(int i,int j)//坏格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j-1] ,up=code[j];
        if(left==0&&up==0)//全无插头时,才能生成新状态
        {
            if(j==M)//j为当前行最后一列,需要右移一位
                shift(code);
            hm[1-cur].push(encode(code),hm[cur].f[k]);
            //printf("***1***%I64o生成%I64o\n",st,encode(code));
        }
    }
}
void dpblank(int i,int j)//好格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        long long num = hm[cur].f[k];
        int code[MAXD];
        decode(code,st);
        int left=code[j-1] ,up=code[j];
        if(left>0&&up>0)//都有插头
        {
            if(left!=up)//合并两个连通分量
            {
                code[j-1]=code[j]=0;
                for(int l=0; l<=M; l++)
                    if(code[l]==up)
                        code[l]=left;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num );
                //printf("***2***%I64o生成%I64o\n",st,encode(code));
            }
            else if( (i==ex&&j>=ey)||(i>ex) )//最后一个好格之后的格子都可以作为终结
            {

                code[j-1]=code[j]=0;
                bool ok = true;//如果此点终结，那么当code的状态中除了left连通分量外再无其他连通分量时才能算终结
                for(int l=0;l<=M;l++)
                    if(code[l]!=0&&code[l]!=left)
                    {
                        ok=false;
                        break;
                    }
                if(ok) sum+= num;

                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                //printf("***3***%I64o生成无\n",st);
                //hm[1-cur].push( encode(code),num );
            }
            //if(j==M)shift(code);//j为当前行最后一列,需要右移一位
            //    hm[1-cur].push( encode(code),num );
            //这两句不能从上面提到这里来,因为这个大块中不仅是这两种情况
        }
        else if(left>0||up>0)//其中一个有插头另一个没有
        {
            if(mp[i][j+1]!=0)
            {
                code[j-1]=0;
                code[j]=left+up;
                if(j==M)shift(code);
                hm[1-cur].push( encode(code),num );
                //printf("***4***%I64o生成%I64o\n",st,encode(code));
            }
            if(mp[i+1][j]!=0)//(i,j)下面是个好格
            {
                code[j-1]=left+up;
                code[j]=0;
                if(j==M)shift(code);
                hm[1-cur].push( encode(code),num );
                //printf("***5***%I64o生成%I64o\n",st,encode(code));
            }
        }
        else//两个都没插头
        {
            if(mp[i][j+1]!=0&&mp[i+1][j]!=0)
            {
                int max_c=1;
                for(int l=0; l<=M; l++)
                    if(max_c<code[l])
                        max_c = code[l];
                code[j-1]=code[j]=max_c+1;
                hm[1-cur].push( encode(code),num );
                //printf("***6***%I64o生成%I64o\n",st,encode(code));
            }
        }
    }
}
void init()
{
    ex=ey=0;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            char a;
            scanf("%c",&a);
            if(a=='O')
            {
                mp[i][j]=1;//必走格为1
                ex=i;
                ey=j;
            }
            else if(a=='*')
            {
                mp[i][j]=2;//可选的格子为2
            }
        }
        getchar();//读'\n'
    }
}
void solve(int kase)
{
    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]==1)
                dpblank(i,j);
            else if(mp[i][j]==0)
                dpblock(i,j);
            else if(mp[i][j]==2)
            {
                dpblank(i,j);
                dpblock(i,j);
            }
            cur=1-cur;
            //printf("(%d,%d)的hm.size=%d\n",i,j,hm[cur].size);
            //for(int k=0;k<hm[cur].size;k++)
                //printf("hm[%d].state[%d]=%I64o,f=%I64d\n",cur,k,hm[cur].state[k],hm[cur].f[k]);
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];
    printf("Case %d: %I64d\n",kase,sum);
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int kase=1; kase<=T; kase++)
    {
        scanf("%d%d",&N,&M);
        getchar();
        init();
        solve(kase);

    }
    return 0;
}