HDU1964

HDU1964 PIPES

现在给你一个矩阵，矩阵中都是好格，要你求一条代价最小的回路，这条回路走过了矩阵的所有格子仅一次。任意两个相邻的矩阵格子之间有费用（0到9的一个整数）。

如上面这个4*3的矩阵，空白的地方表示的是矩阵必须要行走的格子，所有数字的地方表示的是矩阵两个相邻格子之间行走的花费，#的地方是没有路也没格子的。

输入：第一个数字的T，表示实例个数。接下来每个实例，第一行是r和c (2 <= r <= 10),表示这是个r*c行的矩阵,接下来一共有2*r+1行,每行有2c+2个字符(包括每行尾的换行符).

输出:输出构成所能构成的回路最小代价.

分析:解法一:插头DP.本题不是求构成一条回路有多少种方式,而是求构成回路的最小代价,所以我们把HASHMAP中的f[i]=x表示成当前状态是第i号状态时,所需要的最小代价为x.

当处理(i,j)格子时，每当它连上的它的上或左插头时，就把处理完（i，j）格子的状态f值加上它连上的插头的代价即可。

本来我还想这题目用TSP来解下的，但是10*10的规模就是100个节点，TSP解不了。

AC代码：62ms

#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int STATE=1000000+10;//逐格递推每次最多能生成的状态总数,为什么100W能装下,实例测试如果装不下hasnmap就会越界报错
const int HASH = 30007;
const int MAXD=15;
int N,M;
int ex,ey;//最后一个好格的坐标
int cur;
int mp[MAXD][MAXD];
int dist[MAXD][MAXD][4];//表示(i,j)格子朝上下左右4个方向的距离
const int UP=0,DOWN=1,LEFT=2,RIGHT=3;
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]=min(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 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];//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+dist[i][j][LEFT]+dist[i][j][UP] );
            }
            else if(i==ex&&j==ey)//最后一个好格
            {
                sum =min(sum, num+dist[i][j][LEFT]+dist[i][j][UP] );//总数增加
                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)//其中一个有插头另一个没有
        {
            int value;
            if(left)
                value = dist[i][j][LEFT];
            else
                value = dist[i][j][UP];
            if(mp[i][j+1]==1)//(i,j)右边是个好格
            {
                code[j-1]=0;
                code[j]=left+up;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num+value );
            }
            if(mp[i+1][j]==1)//(i,j)下面是个好格
            {
                code[j-1]=left+up;
                code[j]=0;
                if(j==M)shift(code);//j为当前行最后一列,需要右移一位
                hm[1-cur].push( encode(code),num +value);
            }
        }
        else//两个都没插头
        {
            if(mp[i][j+1]==1&&mp[i+1][j]==1)//(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 );
            }
        }
    }
}
void init()
{
    char ss[100];
    ex=N;
    ey=M;
    memset(mp,0,sizeof(mp));
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            dist[i][j][0]=dist[i][j][1]=dist[i][j][2]=dist[i][j][3]=1e9;//初始化(i,j)格子到它4个方向相邻格的花费
            mp[i][j]=1;//所有格子都是可行格,mp依然被0边界包围
        }
    gets(ss);//读######################
    for(int i=1; i<=N-1; i++)//每次处理两行
    {
        for(int j=0; j<=2*M; j++)
        {
            char x;
            x=getchar();
            if( (j>=2) && (j<=2*M-2) && (j%2==0) )//读取第j/2列到j/2+1列的代价
                dist[i][j/2][RIGHT]=dist[i][j/2+1][LEFT]=x-'0';
        }
        getchar();//读'\n'
        for(int j=0; j<=2*M; j++)
        {
            char x;
            x=getchar();
            if( (j>=1) && (j<=2*M-1) && (j%2==1) )//读取第i行第(j+1)/2列到第i+1行第(j+1)/2列的代价
                dist[i][(j+1)/2][DOWN]=dist[i+1][(j+1)/2][UP]=x-'0';
        }
        getchar();//读'\n'
    }
    for(int j=0; j<=2*M; j++)//单独处理倒数第二行,即##########的前面那行
    {
        char x;
        x=getchar();
        if( (j>=2) && (j<=2*M-2) && (j%2==0) )//读取第j/2列到j/2+1列的代价
            dist[N][j/2][RIGHT]=dist[N][j/2+1][LEFT]=x-'0';
    }
    getchar();//读'\n'
    gets(ss);//读######################
}
void solve()
{
    sum=1e10;
    cur=0;
    hm[cur].init();
    hm[cur].push(0,0);//初始时总代价为0
    for(int i=1; i<=N; i++)
        for(int j=1; j<=M; j++)
        {
            hm[1-cur].init();
                dpblank(i,j);
            cur=1-cur;
        }
    //for(int i=0;i<hm[cur].size;i++)
    //sum+=hm[cur].f[i];
    printf("%I64d\n",sum);
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&N,&M);
        getchar();//读\n
        init();
        //for(int i=1; i<=N; i++)
            //for(int j=1; j<=M; j++)
                //printf("(%d,%d)到上下左右的距离为,%d %d %d %d\n",i,j,dist[i][j][UP],dist[i][j][DOWN],dist[i][j][LEFT],dist[i][j][RIGHT]);
        if(ex==0)//全是坏格子
        {
            printf("0\n");
            continue;
        }
        solve();
    }
    return 0;
}