ZOJ 3213

ZOJ 3213 Beautiful Meadow

现在有一个N*M矩阵,你走在矩阵上的好格可以获得上面的分数,坏格子不能走且分数为0.现在你可以从矩阵上的任何一个好格子出发,然后在矩阵中任何一个好格子结束,搜集分数,且每个格子只能走一次.问你最多能得到多少分.

输入:首先是一个T (1 <= T < 60),表示实例个数.然后每个实例第一行是N(1 <= N < 8)和M(1 <= M < 8),然后是这个矩阵的数字描述,为0的格子是不可以走的坏格子.

输出:输出最大分数.

分析:增加标记位标记当前状态中独立插头已经有几个了,最多只能有2个.

如果该格子有左插头和上插头,只能合并不同的连通分量.

 

如果该格子只有左插头或上插头,那么可以继续前进,也可以补一个独立插头,然后下和右就没插头了.

 

该格子没有左上插头,那么:

如果该格子右边和下边可行,就可以补一个新的连通分量

如果该格子右边可行,可以补一个右的独立插头

如果该格子下边的格子可行,可以补一个朝下的独立插头.

 

以上规则可以保证,如果分数最大的路线是至少走了2格的话,那么一定能找到,且最后保留下来的终结状态一定都是有2个独立插头的.

当最大路线只有一格的时候,就不好找了,因为独立插头只有一个,所以我们令sum = max(mp[i][j])即可.且最后sum要去对比所有保存下来的状态的F值.

写程序的时候遇到个BUG,找了好久,因为一个大块中有几个if语句,这几个if语句都可以执行,当上面那个if执行完之后,它还执行了shift操作,直接改变了code的格局(不仅仅是code[j-1]和code[j]了),然后直接导致如果继续执行下面的if会压入错误的状态,找了好久这个BUG.

AC代码:120ms

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 10007;
const int MAXD=15;
int N,M;
int cur;
int mp[MAXD][MAXD];
int code[MAXD];
int sum;//记录最终的最大值
int DL;//独立插头的个数
struct HASHMAP
{
    int size,head[HASH],next[STATE];//next[i]=j表示第i个状态后面链接着第j个状态
    long long state[STATE];//state[i]=S表第i个状态是S
    int f[STATE];//f[i]=x表第i个状态有x种情况
    void init()
    {
        memset(head,-1,sizeof(head));
        size=0;
    }
    void push(long long st, int num)
    {
        long long h = st%HASH;
        int i;
        for(i=head[h]; i!=-1; i=next[i])
        {
            if(state[i]==st)
            {
                f[i]=max(num,f[i]);
                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,st的最低位(最右边)保存独立插头个数(单独用DL记录)
{
    DL = st&7;
    st>>=3;
    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];
    }
    st<<=3;
    st|=DL;
    return st;
}
void shift(int *code)//处理完了一行的最后一列,将code整体右移一位,首位添0
{
    //独立插头的第M+1位没变
    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]);
        }
    }
}
void dpblank(int i,int j)//好格
{
    for(int k=0; k<hm[cur].size; k++)
    {
        long long st=hm[cur].state[k];
        int num = hm[cur].f[k];
        int code[MAXD];
        decode(code,st);//此时DL已更新
        int left=code[j-1] ,up=code[j];
        int code_save[MAXD];
        memcpy(code_save,code,sizeof(code));
        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+mp[i][j]);
            }
        }
        else if(left>0||up>0)//其中一个有插头另一个没有
        {
            if(mp[i][j+1])//(i,j)右边是个好格
            {
                code[j-1]=0;
                code[j]=left+up;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num+mp[i][j]);
            }
            if(mp[i+1][j])//(i,j)下面是个好格<-***这个块里面之前有个好大的BUG,如果上面那个if执行了而且
            //正好shift右移了一位,那么下面这个if再执行的时候就会出现错误的code压入哈希表中,所以...
            {
                memcpy(code,code_save,sizeof(code));

                code[j-1]=left+up;
                code[j]=0;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num +mp[i][j]);
            }

            //左上只有一个插头的时候还可以接独立插头
            if(DL<2)
            {
                memcpy(code,code_save,sizeof(code));
                DL++;
                code[j-1]=0;
                code[j]=0;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num +mp[i][j]);
            }
        }
        else//两个都没插头
        {
            if(mp[i][j+1]&&mp[i+1][j])//(i,j)格的右边和下边是可行格,才可以新生成一个连通分量
            {
                code[j-1]=code[j]=13;
                hm[1-cur].push( encode(code),num+mp[i][j] );
            }
            if(DL<2)//独立插头数目小于2个
            {
                DL++;
                if(mp[i][j+1])//(i,j)右边是个好格
                {
                    memcpy(code,code_save,sizeof(code));
                    code[j-1]=0;
                    code[j]=13;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num+mp[i][j]);
                }
                if(mp[i+1][j])//(i,j)下面是个好格
                {
                    memcpy(code,code_save,sizeof(code));
                    code[j-1]=13;
                    code[j]=0;
                    if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                    hm[1-cur].push( encode(code),num +mp[i][j]);
                }
            }
        }
    }
}
void init()
{
    sum=0;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            scanf("%d",&mp[i][j]);
            if(sum<mp[i][j])
                sum=mp[i][j];
        }
    }
}
void solve()
{
    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[1-cur].init();
            if(mp[i][j])
            {
                dpblank(i,j);
                dpblock(i,j);
            }
            else
                dpblock(i,j);
            cur=1-cur;
        }
    for(int i=0; i<hm[cur].size; i++)
        if(sum<hm[cur].f[i])
            sum=hm[cur].f[i];
    printf("%d\n",sum);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&M);
        init();
        solve();
    }
    return 0;
}