插头DP——从不会到入门（POJ 2411，HDU 1565，HDU 2167，HDU 1693，Ural 1519）

    最近两周一直在刷DP题，前几天接触了插头DP。说实话，直接做“入门”题Ural 1519 Formula 1难度略大，而网上也没有个由浅入深的题表和教程。故总结了一下最近做的、适合作为插头DP专题入门题的题目，专心写一篇博客。大牛见笑。

    学习插头DP前，你得搞清楚状态压缩DP是什么。这里推荐AcCry的一篇状态压缩教程：状态压缩总结。刷完教程里的8题之后，状态压缩DP也就是入门了，也就可以开始学习插头DP了。

POJ 2411 Mondriaan's Dream

    1*2砖填充矩形，问多少种方法。这道题一般想到的方法都是状态压缩DP，上面AcCry的教程中也有这题。但是有更快的方法（不是打表= =），我们可以不按照一行一行匹配、转移的做法，而是一格一格直接转移。这是我第一次接触插头DP，在这篇解题报告上看到的：http://blog.youkuaiyun.com/fp_hzq/article/details/6427072。他写的代码很短，POJ上16MS搞定，让我顿时来了兴趣。不过他的代码真的不好理解。研究了很久，画个图给大家看吧。我们可以用1表示该处竖着放一块砖，用0表示横着放的砖，或者竖着放的第二行。或者这样说，1表示下一行此处不可以放砖，0表示下一行此处可以放砖。状态的转移有两种。见下图。

    然后，代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

long long dp[2][1<<11];

int main()
{
	int n,m;
	while(scanf("%d%d",&n,&m),(n||m))
	{
		int total=1<<m;
		int pre=0,now=1;
		memset(dp[now],0,sizeof(dp[now]));
		dp[now][0]=1;

		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
		{
			swap(now,pre);
			memset(dp[now],0,sizeof(dp[now]));

			for(int S=0;S<total;S++) if( dp[pre][S] )
			{
				dp[now][S^(1<<j)]+=dp[pre][S];
				if( j && S&(1<<(j-1)) && !(S&(1<<j)) )
					dp[now][S^(1<<(j-1))]+=dp[pre][S];
			}
		}

		printf("%lld\n",dp[now][0]);
	}
}

    这是初学的时候写的代码，下面给出模板化的代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define LL long long 

const int maxn=2053;
struct Node
{
	int H[maxn];
	int S[maxn];
	LL N[maxn];
	int size;
	void init()
	{
		size=0;
		memset(H,-1,sizeof(H));
	}

	void push(int SS,LL num)
	{
		int s=SS%maxn;
		while( ~H[s] && S[H[s]]!=SS )
			s=(s+1)%maxn;

		if(~H[s])
		{
			N[H[s]]+=num;
		}
		else
		{
			S[size]=SS;
			N[size]=num;
			H[s]=size++;
		}
	}

	LL get(int SS)
	{
		int s=SS%maxn;
		while( ~H[s] && S[H[s]]!=SS )
			s=(s+1)%maxn;

		if(~H[s])
		{
			return N[H[s]];
		}
		else
		{
			return 0;
		}
	}
} dp[2];
int now,pre;

int get(int S,int p,int l=1)
{
	if(p<0) return 0;
	return (S>>(p*l))&((1<<l)-1);
}

void set(int &S,int p,int v,int l=1)
{
	S^=get(S,p,l)<<(p*l);
	S^=(v&((1<<l)-1))<<(p*l);
}

int main()
{
	int n,m;
	while( scanf("%d%d",&n,&m),n||m )
	{
		if(n%2 && m%2) {puts("0");continue;}

		int now=1,pre=0;
		dp[now].init();
		dp[now].push(0,1);

		for(int i=0;i<n;i++) for(int j=0;j<m;j++)
		{
			swap(now,pre);
			dp[now].init();

			for(int s=0;s<dp[pre].size;s++)
			{
				int S=dp[pre].S[s];
				LL num=dp[pre].N[s];
				int p=get(S,j);
				int q=get(S,j-1);

				int nS=S;
				set(nS,j,1-p);
				dp[now].push(nS,num);

				if(p==0 && q==1)
				{
					set(S,j-1,0);
					dp[now].push(S,num);
				}
			}
		}

		printf("%lld\n",dp[now].get(0));
	}
}

    按照Kuangbin大神说的，自己慢慢形成自己的模板风格就好了。

    这一题，主要学习逐格递推的方式。状态压缩DP是枚举两行的状态，找到匹配的状态后转移，复杂度为n*2^2n。而逐格转移省去了很多无用的状态，复杂度也小了很多，为n^2*2^n。

HDU 1565 方格取数(1)

    依旧是状态压缩DP可以做的题目。取一个数字，周围四个数字不可取。做法类似于上题。取数字的位置标记为1，不取标记为0。转移时，我一定可以不取。如果当前行上一行没有取数字，左边的一格没有取数字，这一格我可以取。代码如下：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int dp[2][1<<20];

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int total=1<<n;
        int now=1,pre=0;
        for(int S=0;S<total;S++)
            dp[now][S]=-1;
        dp[now][0]=0;

        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
        {
            swap(now,pre);
            for(int S=0;S<total;S++)
                dp[now][S]=-1;
            
            int v;
            scanf("%d",&v);
            for(int S=0;S<total;S++) if(~dp[pre][S])
            {
                int not=S&(~(1<<j));
                dp[now][not]=max(dp[now][not],dp[pre][S]);
                if(!(S&(1<<j)) && ( j==0 || (j>0 && !(S&(1<<(j-1)))) ))
                    dp[now][S^(1<<j)]=max(dp[pre][S]+v,dp[now][S^(1<<j)]);
            }
        }

        int ans=0;
        for(int S=0;S<total;S++) if(~dp[now][S])
            ans=max(ans,dp[now][S]);
        printf("%d\n",ans);
    }
}

    模板化代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
#define LL long long 
const int maxn=10011;

struct Node
{
    int H[maxn];
    int S[maxn];
    int N[maxn];
    int size;
    void init()
    {
        size=0;
        memset(H,-1,sizeof(H));
    }

    void push(int SS,int num)
    {
        int s=SS%maxn;
        while( ~H[s] && S[H[s]]!=SS )
        {
            s++;
            s%=maxn;