HDU3377 Plan

题目链接：hdu3377

题目大意：

现在给你一个N*M的矩阵，矩阵每个格子都有一个分数，现在要求你从矩阵左上角走到矩阵右下角去能获得的最大分数。

输入：包含多组实例。每个实例首先是一行N和M，然后是这个矩阵，矩阵中的每个分数在[-2000，2000]内。

输出：从左上角走到右下角的最大分数。

分析：除了左上角和右下角外其他格子都是可选择的，不能构成一个圈。我们在这N*M的矩阵上再加一行一列（加第一行和最后一列），使得这个矩阵变成(N+1)*(M+1)的矩阵，而且我们加的格子都是分值为0的必须走的格子，那么现在我们如果找到目标路径的话，再加上我们加的这一行一列就正好构成了一个圈。如下图；

原矩阵：

1 2

3 1

新矩阵：

0 0 0

1 2 0

3 1 0.

现在检测到一个BUG，原矩阵是

0   -2   100

1   -20   -20

1    1      1

构造后的矩阵为：

0   0    0     0

0 -20  100     0

1 -20  -20     0

1  1   1      0

原题的答案是61，但是我们计算的答案是84，我们程序没出错，我们建模出错了。我们程序在图中走的圈是上图中蓝色的线走的圈，这个结果是84但是明显不是我们想要的，我们想要的是外面这两条全0的横线和竖线直接沿这个走而不在线段中拐弯到里面去。只要保证这个虚构的第一行和虚构的最后一列一气呵成走完就可以完成达到我们的要求。我们只需要在图中限制下图中红色的0只能单向前进就OK了。第一行的红0只能右转，绿0只能向下走。

0  0  0 0

           0

           0

           0

红0是那些行号为 1列号2<=C<=M的格子，即这些格子只能往右直走。

绿0是那些列号C==M+1，行号1<=r<=N的格子，它们只能往下走。

 //通过限制扩充格的行走路径来解决此题 

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;//1<<15=32768
const int MAXD=15;
int N,M;
int ex,ey;//最后一个好格的坐标
int cur;
int mp[MAXD][MAXD];
int code[MAXD];
int cost[MAXD][MAXD];//表示(i,j)格子的花费
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]=max(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;//7 111  连通的插头标记相同的数字  最多可以有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)//好格
{
    if(i==1&&2<=j&&j<=M-1)//红0只能往右走
    {
    	for(int k=0; k<hm[cur].size; k++)
		{
			long long st=hm[cur].state[k];
			long long num = hm[cur].f[k];//num是状态为st时的最小费用
			int code[MAXD];
			decode(code,st);
			int left=code[j-1] ,up=code[j];
			if(left>0&&up==0)//其中一个有插头另一个没有
			{
				if(mp[i][j+1]!=0)//(i,j)右边是个好格
				{
					code[j-1]=0;
					code[j]=left+up;
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					hm[1-cur].push( encode(code),num+cost[i][j] );
				}
			}
		}
    }
    else if(i==1&&j==M)//右上角的拐角处特殊处理  他有左插头 但要往下走
	{
		for(int k=0; k<hm[cur].size; k++)
		{
			long long st=hm[cur].state[k];
			long long num = hm[cur].f[k];//num是状态为st时的最小费用
			int code[MAXD];
			decode(code,st);
			int left=code[j-1] ,up=code[j];
			if(left>0&&up==0)//其中一个有插头另一个没有
			{
				 if(mp[i+1][j]!=0)//(i,j)下面是个好格
				{
					code[j-1]=left+up;
					code[j]=0;
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					hm[1-cur].push( encode(code),num +cost[i][j]);
				}
			}
		}
	}
	else if(i>=2&&i<N&&j==M)//绿的0 只有上插头 但只能往下直走
	{
		for(int k=0; k<hm[cur].size; k++)
		{
			long long st=hm[cur].state[k];
			long long num = hm[cur].f[k];//num是状态为st时的最小费用
			int code[MAXD];
			decode(code,st);
			int left=code[j-1] ,up=code[j];
			if(left==0&&up>0)//其中一个有插头另一个没有
			{
				 if(mp[i+1][j]!=0)//(i,j)下面是个好格
				{
					code[j-1]=left+up;
					code[j]=0;
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					hm[1-cur].push( encode(code),num +cost[i][j]);
				}
			}
		}
	}
	else//原矩形内的情况
	{
		for(int k=0; k<hm[cur].size; k++)
		{
			long long st=hm[cur].state[k];
			long long num = hm[cur].f[k];//num是状态为st时的最小费用
			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+cost[i][j]);
				}
				else if(i==ex&&j==ey)//最后一个好格
				{
					sum =max(sum, num+cost[i][j] );//总数增加
					code[j-1]=code[j]=0;
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					//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)//(i,j)右边是个好格
				{
					code[j-1]=0;
					code[j]=left+up;
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					hm[1-cur].push( encode(code),num+cost[i][j] );
				}
				if(mp[i+1][j]!=0)//(i,j)下面是个好格
				{
					code[j-1]=left+up;
					code[j]=0;
					if(j==M)shift(code);//j为当前行最后一列,需要右移一位
					hm[1-cur].push( encode(code),num +cost[i][j]);
				}
			}
			else//两个都没插头
			{
				if(mp[i][j+1]!=0&&mp[i+1][j]!=0)//(i,j)格的右边和下边是可行格,才可以新生成一个连通分量
				{
					//这里不会出现j是最后一列的情况
					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 +cost[i][j]);
				}
			}
		}
	}
}

void init()
{
	ex=N+1;
	ey=M+1;
	memset(mp,0,sizeof mp);
	for(int i=2;i<=N+1;i++)
		for(int j=1;j<=M;j++)
	{
		scanf("%d",&cost[i][j]);
		mp[i][j]=2;//这个点可选
	}
	mp[2][1]=mp[N+1][M]=1;//原左上角和右上角必须走
	for(int j=1;j<=M+1;j++)//第一行必须走
	{
		cost[1][j]=0;
		mp[1][j]=1;
	}

	for(int i=2;i<=N+1;i++)
	{
		cost[i][M+1]=0;
		mp[i][M+1]=1;
	}
	N++;//注意  这里将矩形扩大  方便后面的使用
	M++;
}

void solve()
{
    sum=-1e8;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,0);//初始时总代价为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;
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];

}
int main()
{
	 int T=1;
    while(~scanf("%d%d",&N,&M))
    {

        init();
        solve();
		printf("Case %d: %I64d\n",T++,sum);
    }
    return 0;
}