ants(插頭DP)

有一個N*N的矩陣，需要用若干循環將其鋪滿，使得每個格子都處於一個循環上，求方案數，逆時針和順時針的循環算作不同的方案。n<=10.

插頭DP，用0表示空，1表示插向輪廓線下側的插頭，2表示插向輪廓線上側的插頭。一共有9種轉移，分類討論即可。實現的過程中可以用4進制來代替3進制。

由於我直接用的city那道題的插頭DP模板，結果N=8以上就卡了很久。注意換行的時候不能直接移位，因爲會產生不合法的狀態，要把移出去的頭砍掉，或者在轉移的時候特判。還有轉移的時候最好在各種地方加上防止不合法狀態的特判，這樣才能保證轉移時候的狀態數在預計的範圍內。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<set>
#include<assert.h>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define erp(i,a,b) for(int i=a;i>=b;--i)
#define getbit(x,y) (((x) >> ((y)<<1)) & 3)
#define bit(x,y) ((x)<<((y)<<1))
#define clrbit(x,i,j) ((x) & (~(3<<((i)<<1))) & (~(3<<((j)<<1))))
#define LL long long
using namespace std;
const int mo = 100003, MAXS = 100000;
int N;

struct Node
{
	int s, nxt;
	LL val;
};
struct Hash
{
	Node e[MAXS];
	int adj[mo], ec;
	void init()
	{
		memset(adj, -1, sizeof adj);
		ec = 0;
	}
	void push(int s, LL v)
	{
		int ha = s%mo;
		for (int i = adj[ha]; ~i; i=e[i].nxt)
			if (e[i].s == s)
			{
				e[i].val += v;
				return;
			}
		e[ec].val = v, e[ec].s = s;
		e[ec].nxt = adj[ha];
		adj[ha] = ec++;
	}
} dp[2];

void work(int i, int j, int cur)
{
	dp[cur].init();
	rep(k, 0, dp[cur^1].ec-1)
	{
		int lass = dp[cur^1].e[k].s;
		if (lass >= (1<<((N+1)<<1))) continue; //這個非常重要！！
		int L = getbit(lass, j-1);
		int U = getbit(lass, j);
		int s = clrbit(lass, j-1, j);
		LL las = dp[cur^1].e[k].val;
		if (!L && !U)
		{
			if (j!=N) dp[cur].push(s | bit(1,j) | bit(2,j-1), las);
			if (i!=N) dp[cur].push(s | bit(2,j) | bit(1,j-1), las);
		}
		else if (!L && U==1)
		{
			dp[cur].push(s | bit(0,j-1) | bit(1,j), las);
			if (i!=N) dp[cur].push(s | bit(1,j-1) | bit(0,j), las);
		}
		else if (!L && U==2)
		{
			dp[cur].push(s | bit(0,j-1) | bit(2,j), las);
			dp[cur].push(s | bit(2,j-1) | bit(0,j), las);
		}
		else if (L==1 && !U)
		{
			dp[cur].push(s | bit(0,j-1) | bit(1,j), las);
			if (i!=N) dp[cur].push(s | bit(1,j-1) | bit(0,j), las);
		}
		else if (L==1 && U==2)
		{
			dp[cur].push(s, las);
		}
		else if (L==2 && !U)
		{
			dp[cur].push(s | bit(0,j-1) | bit(2,j), las);
			dp[cur].push(s | bit(2,j-1) | bit(0,j), las);
		}
		else if (L==2 && U==1)
		{
			dp[cur].push(s, las);
		}
	}
}

LL solve()
{
	dp[0].init(), dp[0].push(0, 1);
	int cur = 0;
	rep(i, 1, N)
	{
		rep(k, 0, dp[cur].ec-1)
		dp[cur].e[k].s <<= 2; //注意這樣寫會產生大量不合法狀態。轉移時特判即可。
		rep(j, 1, N)
		{
			cur ^= 1;
			work(i, j, cur);
		}
	}
	rep(k, 0, dp[cur].ec-1)
		if (dp[cur].e[k].s == 0)
			return dp[cur].e[k].val;
	return 0;
}

int main()
{
	cin >> N;
	if (N&1) puts("0");
	else cout << solve() << '\n';
	return 0;
}