POJ 3133 Manhattan Wiring

题目链接：http://poj.org/problem?id=3133

题意：给一个地图上有两个2，两个3，以及障碍格子和非障碍格子，现在要把两个2用线连接起来，两个3用线连接起来，求连接线之和的最小长度。

思路：插头dp，格子分类：2/3格子 ， 普通格子 ， 障碍格子。2/3格子只能为单插头 ， 普通格子为0插头或者2插头。其次是连通性，分2号线连通和3号线连通，即用4进制表示轮廓线的连通线，0表示无插头，1表示2号线插头，2表示3号线插头。注意插头的合并只能合并相同类型。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long
#define Clean(x,y) memset(x,y,sizeof(x))
int n,m;
int pre,cur;

int g[20][20];
const int maxn = 1009999;

int bit = 3;
int inc = 2;
int code[20];
int vis[20];

struct hash_table
{
    int head[60007] , next[maxn];
    LL value[maxn] , state[maxn];
    int size;
    void clear()
    {
        size = 0;
        Clean(head,-1);
    }
    void push( LL S , LL V )
    {
        int index = S % 60007;
        for( int k = head[index]; k != -1; k = next[k] )
            if ( state[k] == S )
            {
                value[k] = min( value[k] , V );
                return;
            }
        state[size] = S , value[size] = V;
        next[size] = head[index] , head[index] = size++;
    }
}dp[2];

void init()
{
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
        scanf("%d",&g[i][j]);
}


inline void decode( LL S , int m )
{
    for( int i = 0; i <= m; i++ ) code[i] = S & bit , S >>= inc;
}

inline int encode( int m )
{
    int ans = 0;

    for( int i = m; i >= 0; i-- )
    {
        ans <<= inc;
        ans |= code[i];
    }
    return ans;
}

void DP( int x , int y , int k ) //0表示无线  1表示未知线  2表示2线  3表示3线
{
    decode( dp[pre].state[k] , m );
    int left = code[y-1] , up = code[y];
    int V = dp[pre].value[k];
    int S = dp[pre].state[k];
    code[y] = code[y-1] = 0;

    if ( g[x][y] == 1 ) //不可走的格子
    {
        if ( !left && !up ) dp[cur].push( S , V );//无插头才能转移
    }
    else if ( g[x][y] == 0 ) // 空白格
    {
        if ( !left && !up )
        {
            dp[cur].push( encode(m) , V );//无插头可以不走此格子
            if ( x < n && y < m && g[x+1][y] != 1 && g[x][y+1] != 1 ) //双插头
            {
                //分别尝试作为2/3的线
                code[y-1] = code[y] = 2 , dp[cur].push( encode(m) , V + 1 );
                code[y-1] = code[y] = 3 , dp[cur].push( encode(m) , V + 1 );
            }

        }
        else if ( !left || !up ) //有单插头 ， 还需要一个插头
        {
            if ( x < n && g[x+1][y] != 1 ) //下面的格子是可连线 ， 下插头
                code[y-1] = left + up , dp[cur].push( encode(m) , V + 1 ) , code[y-1] = 0;
            if ( y < m && g[x][y+1] != 1 ) //右插头
                code[y] = left + up , dp[cur].push( encode(m) , V + 1 );
        }
        else if ( left == up ) //两个插头合并，同线合并
            dp[cur].push( encode(m) , V + 1 );
    }
    else //格子为2 / 3的起点/终点  只能有单插头
    {
        if( !up && !left ) //寻找一个右/下插头
        {
            if ( x < n && g[x+1][y] != 1 ) //下面的格子是可连线 ， 下插头
                code[y-1] = g[x][y] , dp[cur].push( encode(m) , V ) , code[y-1] = 0;
            if ( y < m && g[x][y+1] != 1 ) //右插头
                code[y] = g[x][y] , dp[cur].push( encode(m) , V );
        }
        else if ( !left || !up ) //已有相同插头了，结束！
        {
            if ( left + up == g[x][y] ) dp[cur].push( encode(m) , V );
        }
    }
}

int solve()
{
    cur = 0;
    dp[0].clear();
    dp[0].push( 0 , 0 );

    for( int i = 1; i <= n; i++ )
    {
        pre = cur , cur ^= 1;
        dp[cur].clear();
        for( int k = 0; k < ( dp[pre].size ); k++ )
        dp[cur].push( dp[pre].state[k]<<inc , dp[pre].value[k] );

        for( int j = 1; j <= m; j++ )
        {
            pre = cur , cur ^= 1 , dp[cur].clear();
            for( int k = 0; k < dp[pre].size; k++ ) DP( i , j , k );
        }
    }
    for( int k = 0; k < dp[cur].size; k++ )
        if ( dp[cur].state[k] == 0 ) return dp[cur].value[k] + 2;
    return 0;
}

int main()
{
    while( scanf("%d%d",&n,&m) == 2 )
    {
        if ( n + m == 0 ) break;
        init();
        printf("%d\n",solve());
    }
    return 0;
}