算法模板（4）：动态规划（2）

8.树形DP

没有上司的舞会

树上最大独立集问题

Ural 大学有 $N$ 名职员，编号为 $1\sim N$。他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。每个职员有一个快乐指数，用整数 $H_i$ 给出，其中 $1\le i\le N$。现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。

#include
#include
#include
using namespace std;
const int maxn = 6010;
int h[maxn], e[maxn], ne[maxn], idx;
bool has_father[maxn];
int f[maxn][2], N, happy[maxn];

void add(int a, int b) {
	e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void dfs(int u) {
//f[u][0]是不选u, f[u][1]是选u。
	f[u][1] = happy[u];
	for (int i = h[u]; i != -1; i = ne[i]) {
		int v = e[i];
		dfs(v);
		f[u][0] += max(f[v][0], f[v][1]);
		f[u][1] += f[v][0];
	}
}
int main() {
	memset(h, -1, sizeof h);
	scanf("%d", &N);
	for (int i = 1; i <= N; i++) scanf("%d", &happy[i]);
	for (int i = 1; i < N; i++) {
		int a, b;
		scanf("%d%d", &a, &b);
		add(b, a);
		has_father[a] = true;
	}
	int root;
	for (root = 1; root <= N && has_father[root]; root++);
	dfs(root);
	printf("%d\n", max(f[root][0], f[root][1]));
	return 0;
}

1072. 树的最长路径

• 题意：给定一棵树，树中包含 $n$ 个结点（编号$1$~$n$）和 $n-1$ 条无向边，每条边都有一个权值。现在请你找到树中的一条最长路径。换句话说，要找到一条路径，使得使得路径两端的点的距离最远。注意：路径中可以只包含一个点。

法一：

（1）任取一点 $a$ 作为起点，找到距离该点最远的点 $u$. （2）再找到距离 $u$ 最远的一点 $v$。

则 $u$ 到 $v$ 之间的路径是树的直径. 证明的话，只需证 $u$ 的是直径的一个端点；用反证法，假设 $cd$ 是真的直径，那么可以分为 $cd$ 和 $ua$ 的直径是否有公共点. 具体可以看视频.

#include
using namespace std;
const int N = 10010, M = N * 2, INF = 0x3f3f3f3f;

int h[N], e[M], ne[M], w[M], idx;
int n, d[N];

void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

void dfs(int u, int fa)
{
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(v == fa) continue;
        d[v] = d[u] + w[i];
        dfs(v, u);
    }
}

int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);
    for(int i = 1; i < n; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }
    dfs(1, -1);

    int u = 0, res = -INF;
    for(int i = 1; i <= n; i++)
    {
        if(d[i] > res) res = d[i], u = i;
    }

    d[u] = 0;
    dfs(u, -1);
    res = -INF;
    for(int i = 1; i <= n; i++)
    {
        res = max(res, d[i]);
    }
    printf("%d\n", res);
    return 0;
}

法二：

记录一个子树高度的最大值和次大值即可

int ans;
int dfs(int u, int fa)
{
    int height = 0, max1 = 0, max2 = 0;
    for(int i = h[u]; i != -1; i = ne[i]){
        int v = e[i];
        if(v == fa) continue;
        int nh = dfs(v, u);
        height = max(height, nh + w[i]);
        if(nh + w[i] > max1){
            max2 = max1;
            max1 = nh + w[i];
        }
        else if(nh + w[i] > max2){
            max2 = nh + w[i];
        }
    }
    int res = 0;
    if(max1) res += max1;
    if(max2) res += max2;
    ans = max(ans, res);
    return height;
}

1073. 树的中心

• 题意：给定一棵树，树中包含 $n$ 个结点（编号 $1\sim n$ ）和 $n-1$ 条无向边，每条边都有一个权值。请你在树中找到一个点，使得该点到树中其他结点的最远距离最近。
• 一个点距离其他所有节点的最远距离，是一个点向下走和向上走的最远距离取一个最大值. 对于结点 $v$，其父结点是 $u$，向下走容易求；向上走分为两种，一种是 $u$ 向上走的最大值加上 $w(u,v)$，一种是 $u$ 不经过点 $v$ 的路径向下走的最大值加上 $w(u,v)$. 后者可以求一个向下走的最大值和次大值来获得.

#include
using namespace std;
const int N = 10010, M = N * 2;

int n;
int h[N], e[M], ne[M], w[M], idx;

void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}

int d1[N], d2[N], son1[N], son2[N];
int up[N];

int dfs1(int u, int fa)
{
    
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(v == fa) continue;
        int d = dfs1(v, u) + w[i];
        if(d >= d1[u]) 
        {
            d2[u] = d1[u], d1[u] = d;
            son2[u] = son1[u], son1[u] = v;
        }
        else if(d > d2[u])
        {
            d2[u] = d, son2[u] = v;
        }
    }
    return d1[u];
}

void dfs2(int u, int fa)
{
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(v == fa) continue;
        //直接从当前层推到下一层.
        int dist = w[i] + (son1[u] == v ? d2[u] : d1[u]);
        up[v] = max(dist, w[i] + up[u]);
        dfs2(v, u);
    }
}

int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);
    for(int i = 1; i < n; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }
    dfs1(1, -1);
    dfs2(1, -1);
    int res = 0x3f3f3f3f;
    for(int i = 1; i <= n; i++)
    {
        res = min(res, max(up[i], d1[i]));
    }
    printf("%d\n", res);
    return 0;
}

9.数位统计DP

• 技巧一：$[x,y]=f(y)-f(x-1)$
• 技巧二：用树的角度考虑
• 其实，我感觉，数位 $dp$ 就是一个搜索的过程，从最高位是 $0$ ~ $a_{n-1}$ 开始，最开始填 $\mathrm{000...000}$，然后到$\mathrm{099...999},\mathrm{199...999}$，再到 $(a_{n-1}-1)\mathrm{99...999}$；然后最高位填 $a_{n-1}$，开始填第二位。这样子，确实可以搜索完全部的数字。

杨雅儒告诉我们，$f[i,j,0/1]$ 表示状态，最后一个 $0/1$ 表示是否顶到上界.

度的数量

• 题意：求给定区间 $[X,Y]$ 中满足下列条件的整数个数：这个数恰好等于 $K$ 个互不相等的 $B$ 的整数次幂之和。

• 计算 $f(N)$。把 $N$ 写成 $B$ 进制 $\overline{a_{n-1}{a}_{n-2}...a_0}$。那么，第一位要么填 $a_{n-1}$，要么填 $0$ ~ $a_{n-1}-1$.

• 转化为这道题。因为每一位只能填 $1$ 或 $0$.

  • 当第 $x$ 位为 $0$ 时，只能进到右边那个分支。
  • $x$ 为 $1$ 时，进到左边那个分支时，第 $a_{n-1}$ 位只能填 $0$，那么是 $C_{n-1}^k$ 种填法，其实也就是 $C_i^{K-last}$.
  • $x>1$ 时，那么左边那个分支的第一位可以填 $0$ 或 $1$，但是右边那个分支就没有了。

#include
#include
#include
#include
using namespace std;
typedef long long ll;
const int maxn = 35;
ll C[maxn][maxn];   //组合数
int K, B;
ll dp(int n) {
	if (n == 0) return 0;
	
	vector<int> nums;
	while (n) nums.push_back(n % B), n /= B;   
	ll res = 0;      //保存答案。
	int last = 0;    //保存前缀信息。这里是保存用掉了多少个1

	for (int i = nums.size() - 1; i >= 0; i--) {
		int x = nums[i];
		if (x) {
			res += C[i][K - last];  //C(n-1, K)
			if (x > 1) {
				if (K - last - 1 >= 0) res += C[i][K - last - 1];
				break;
			}
			else {
				last++;
				if (last > K) break;
			}
		}
		if (i == 0 && last == K) res++;  
		//这个求的是方案数。跑到最右边一位时，如果此时一个1也不允许填了，那么此处填0就是这1种方案。
	}

	return res;
}
int main() {
	for (int i = 0; i < maxn; i++) {
		for (int j = 0; j <= i; j++) {
			if (j == 0) C[i][j] = 1;
			else C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
		}
	}
	int L, R;
	cin >> L >> R >> K >> B;
	cout << dp(R) - dp(L - 1) << endl;
}

深搜代码

#include
using namespace std;
const int N = 35;
int f[N][N][2], a[N];
int k, b, X, Y;

int dp(int pos, int k, int lim)
{
    if(pos == -1)
    {
        return k == 0;
    }
    int& v= f[pos][k][lim];
    if(v != -1) return v;
    int up = lim ? min(1, a[pos]) : 1;
    int ans = 0;
    for(int i = 0; i <= up; i++)
    {
        if(k > 0) ans += dp(pos - 1, i == 0 ? k : k - 1, i == a[pos] && lim);
        if(!k && !i) ans += dp(pos - 1, 0, i == up && lim);
    }
    return f[pos][k][lim] = ans;
}

int solve(int x)
{
    int sz = 0;
    while(x)
    {
        a[sz++] = x % b;
        x /= b;
    }
    memset(f, -1, sizeof f);
    return dp(sz - 1, k, 1);
}

int main()
{
    scanf("%d%d%d%d", &X, &Y, &k, &b);
    printf("%d\n", solve(Y) - solve(X - 1));
}

数字游戏

• 题意：某人命名了一种不降数，这种数字必须满足从左到右各位数字呈非下降关系，如 123，446。现在大家决定玩一个游戏，指定一个整数闭区间 $[a,b]$，问这个区间内有多少个不降数。

#include
#include
#include
#include
#include
using namespace std;
const int maxn = 15;
int f[maxn][maxn];  //f[i][j] 表示最高位填 j, 且总共有 i 位的数的个数

int dp(int n) {
	if (n == 0) return 1;
	int res = 0, last = 0;
	vector<int> nums;
	while (n) nums.push_back(n % 10), n /= 10;
	for (int i = nums.size() - 1; i >= 0; i--) {
		int x = nums[i];
		for (int j = last; j < x; j++) {
			res += f[i + 1][j];
		}
		if (last > x) break;
		last = x;
        //程序能走到这里，说明a0也是合法情况，即N这个数字就是不降数
		if (i == 0) res++;
	}
	return res;
}
int main() {
	for (int j = 0; j <= 9; j++) f[1][j] = 1;
	for (int i = 2; i < 15; i++) {
		for (int j = 0; j <= 9; j++) {
			for (int k = j; k <= 9; k++) {
				f[i][j] += f[i - 1][k];
			}
		}
	}
	int a, b;
	while (cin >> a >> b) {
		cout << dp(b) - dp(a - 1) << endl;
	}
	return 0;
}

深搜方法（注意，这道题前导零是合法的。举例来说，表示 $[1,R],R>10$ 中的数字，如果想表示出1，前面就得有前导零）

#include
using namespace std;
const int N = 35;
int f[N][N], A, B;
int a[N];
//搜索到 pos 个位置，上一位是 k，的方案数.
int dp(int pos, int k, int lim)
{
    if(pos == -1) return 1;
    if(!lim && f[pos][k] != -1)
    {
        return f[pos][k];
    }
    int up = lim ? a[pos] : 9;
    int ans = 0;
    for(int i = k; i <= up; i++)
    {
        ans += dp(pos - 1, i, i == up && lim);
    }
    if(!lim) f[pos][k] = ans;
    return ans;
}

int solve(int x)
{
    //if(!x) return 1;
    int sz = 0;
    while(x)
    {
        a[sz++] = x % 10;
        x /= 10;
    }
    memset(f, -1, sizeof f);
    return dp(sz - 1, 0, 1);
}
int main()
{
    while(cin >> A >> B)
    {
        //printf("%d\n%d\n", solve(B), solve(A - 1));
        printf("%d\n", solve(B) - solve(A - 1));
    }
    return 0;
}

10. 单调队列优化DP

135. 最大子序和

• 输入一个长度为 $n$ 的整数序列，从中找出一段长度不超过 $m$ 的连续子序列，使得子序列中所有数的和最大。连续子序列长度至少为 $1$ .
• 打一个前缀和，让 $s[i]-s[i-j],1\le j\le m$ 最大. 就是在 $i-m\sim i-1$ 中找最小值.

#include
using namespace std;
const int N = 300010;
int q[N], s[N];
int n, m;
int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }
    
    int hh = 0, tt = -1;
    int res = -0x3f3f3f3f;
    
    for(int i = 1; i <= n; i++)
    {
        if(q[hh] < i - m) hh++;
        while(hh <= tt && s[q[tt]] >= s[i - 1]) tt--;
        q[++tt] = i - 1;
        res = max(res, s[i] - s[q[hh]]);
    }
    
    printf("%d\n", res);
    
    return 0;
}

1089. 烽火传递

• 在某两个城市之间有 $n$ 座烽火台，每个烽火台发出信号都有一定的代价。为了使情报准确传递，在连续 $m$ 个烽火台中至少要有一个发出信号。现在输入 $n,m$ 和每个烽火台的代价，请计算在两城市之间准确传递情报所需花费的总代价最少为多少。
• 原本思路是 $f(i,j)$，第 $i$ 个烽火台状态为 $j$ 时的代价。不过题解给的是 $f(i)$ 表示 $1\sim i$ 且点燃第 $i$ 个烽火台的代价.
• $f(i)=\underset{i-m\le j<i}{\min }\{f(j)\}+w(i)$.

#include
using namespace std;
const int N = 200010;
int q[N], f[N], w[N];
int n, m;
int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &w[i]);
    }
    
    //这里，0应该是单调队列第一个元素，要作为状态转移的起点
    int hh = 0, tt = -1;
    q[++tt] = 0;
    for(int i = 1; i <= n; i++)
    {
        if(q[hh] < i - m) hh++;
        f[i] = f[q[hh]] + w[i];
        while(hh <= tt && f[q[tt]] >= f[i]) tt--;
        q[++tt] = i;
    }
    
    int ans = 0x3f3f3f3f;
    for(int i = max(1, n - m + 1); i <= n; i++) ans = min(ans, f[i]);
    printf("%d\n", ans);
    return 0;
}

11. 斜率优化DP

12. 基环树DP

如果一张无向连通图包含恰好一个环，则称它是一棵 基环树 (Pseudotree)。

如果一张有向弱连通图每个点的入度都为 $1$，则称它是一棵 基环外向树。

如果一张有向弱连通图每个点的出度都为 $1$，则称它是一棵 基环内向树。

多棵树可以组成一个 森林 (Forest)，多棵基环树可以组成 基环森林 (Pseudoforest)，多棵基环外向树可以组成 基环外向树森林，多棵基环内向树可以组成 基环内向森林 (Functional graph)。

如果一张无向连通图的每条边最多在一个环内，则称它是一棵 仙人掌 (Cactus)。多棵仙人掌可以组成 沙漠。

358. 岛屿

• 在环上进行单调队列优化
• 题意：你准备游览一个公园，该公园由 $N$ 个岛屿组成，当地管理部门从每个岛屿出发向另外一个岛屿建了一座桥，不过桥是可以双向行走的。可证这是一个基环森林。现在求每个基环树的最长的两点之间路径之和。

• 这道题的思路是，找到每一个基环树上面的环，如果两个点位于同一个树上，那么就是树上的直径；如果两点分别位于两棵树上，如上图，那么答案就是 $d_x+d_y+S_x-S_y$.

#include
using namespace std;
const int N = 1000010, M = N * 2;
typedef long long ll;
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
int n;
bool st[N];
int q[2 * N], ins[N]; //ins 表示在栈中
int fu[N], fw[N];  //u的父结点，以及与父结点之间的边权.
int cnt, cir[N], ed[N];
ll s[N], d[N * 2], sum[N * 2], ans;

void dfs_c(int u, int from)
{
    st[u] = ins[u] = true;
    for(int i = h[u]; i != -1; i = ne[i])
    {
        if(i == (from ^ 1)) continue;
        int v = e[i];
        fu[v] = u, fw[v] = w[i];
        if(!st[v]) dfs_c(v, i);
        else if(ins[v])
        {
            cnt++;
            ed[cnt] = ed[cnt - 1];
            ll sum = w[i];
            for(int k = u; k != v; k = fu[k])
            {
                s[k] = sum;
                cir[++ed[cnt]] = k;
                sum += fw[k];
            }
            s[v] = sum, cir[++ed[cnt]] = v;
        }
    }
    ins[u] = false;
}

ll dfs_d(int u)
{
    ll d1 = 0, d2 = 0;
    st[u] = true;
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(st[v]) continue;
        ll dist = dfs_d(v) + w[i];
        if(dist >= d1) d2 = d1, d1 = dist;
        else if(dist > d2) d2 = dist;
    }
    ans = max(ans, d1 + d2);
    return d1;
}


int main()
{
    scanf("%d", &n);
    memset(h, -1, sizeof h);
    for(int i = 1; i <= n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(i, a, b), add(a, i, b);
    }
    for(int i = 1; i <= n; i++)
    {
        if(!st[i]) dfs_c(i, -1);
    }

    memset(st, 0, sizeof st);
    for(int i = 1; i <= ed[cnt]; i++) st[cir[i]] = true;

    ll res = 0;

    for(int i = 1; i <= cnt; i++)
    {
        ans = 0;
        int sz = 0;
        for(int j = ed[i - 1] + 1; j <= ed[i]; j++)
        {
            int k = cir[j];
            d[sz] = dfs_d(k);
            sum[sz] = s[k];
            sz++;
        }

        for(int j = 0; j < sz; j++)
        {
            d[j + sz] = d[j], sum[j + sz] = sum[j] + sum[sz - 1];
        }

        int hh = 0, tt = -1;
        for(int j = 0; j < 2 * sz; j++)
        {
            if(hh <= tt && q[hh] < j - sz + 1) hh++;
            if(hh <= tt) ans = max(ans, d[j] + sum[j] + d[q[hh]] - sum[q[hh]]);
            while(hh <= tt && d[q[tt]] - sum[q[tt]] <= d[j] - sum[j]) tt--;
            q[++tt] = j;
        }
        res += ans;
    }

    printf("%lld\n", res);
    return 0;
}

1080. 骑士

• 破环：基环树上的最大独立集问题

• 从所有骑士 $n\le 10^6$ 中选出一个骑士军团，使得军团内没有矛盾的两人，即不存在一个骑士与他最痛恨的人一同被选入骑士军团的情况，并且使这支骑士军团最富有战斗力。为描述战斗力，我们将骑士按照 $1$ 至 $N$ 编号，给每位骑士一个战斗力的估计，一个军团的战斗力为所有骑士的战斗力之和。每个骑士均有一个最痛恨的人。

• 可以类比 没有上司的舞会，对于每一个基环树，我们找到环上的一个点 $u$，假设环上另一个点是 $v$，那么我们讨论一下 $u$ 和 $v$ 之间是否要断开。断开意味着之前 $u$ 和 $v$ 不能同时选但是现在可能会同时选了，只要避免掉这个情况就可以了. 如果不选 $u$ 的话，那么这条边是否删掉后也不改变答案. 如果选 $u$ 的话，由于 $(u,v)$ 被删掉了，那么我们特判不选择 $v$ 即可. 综上，我们删掉这条边之后，只需要不同时选 $u$ 和 $v$ 即可.

• 最后答案就是 $\max \{f(u,0),f(u,1)\}$.

• 所有出度都为1，是内向基环树，建反向边.

#include
#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
const int N = 1000010;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
int h[N], e[N], ne[N], w[N], idx, rm[N];
int n;
ll f1[N][2], f2[N][2], ans;
bool st[N], ins[N];
inline void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

void dfs_f(int u, int pa, ll f[][2])
{
    for(int i = h[u]; i != -1; i = ne[i])
    {
        if(rm[i]) continue;
        int v = e[i];
        dfs_f(v, pa, f);
        f[u][0] += max(f[v][0], f[v][1]);
    }
    
    f[u][1] = -INF;
    if(u != pa)
    {
        f[u][1] = w[u];
        for(int i = h[u];i != -1; i = ne[i])
        {
            if(rm[i]) continue;
            int v = e[i];
            f[u][1] += f[v][0];
        }
    }
}

void dfs_c(int u)
{
    st[u] = ins[u] = true;
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(!st[v]) dfs_c(v);
        else if(ins[v])
        {
            rm[i] = 1;
            dfs_f(v, -1, f1);
            dfs_f(v, u, f2);
            ans += max(f1[v][0], f2[v][1]);
        }
    }
    ins[u] = false;
}


int main()
{
    memset(h, -1, sizeof h);
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        int v;
        scanf("%d%d", &w[i], &v);
        add(v, i);
    }
    for(int i = 1; i <= n; i++)
    {
        if(!st[i]) dfs_c(i);
    }
    printf("%lld\n", ans);
    return 0;
}

13. 四边形不等式DP

基本概念

定义一：设 $w(x,y)$ 是定义在整数集合上的二元函数。$\forall a,b,c,d,a\le b\le c\le d,w(a,d)+w(b,c)\ge w(a,c)+w(b,d)$.

定义二：设 $w(x,y)$ 是定义在整数集合上的二元函数。若对于定义域上的任意整数 $a,b$，其中 $a<b$，都有 $w(a,b+1)+w(a+1，b)\ge w(a,b)+w(a+1,b+1)$.
$$f_{l,r}=\underset{k=l}{\overset{r-1}{\min }}\{f_{l,k}+f_{k+1,r}\}+w(l,r)\left(1\le l<r\le n\right)$$

直接简单实现状态转移，总时间复杂度将会达到 $O(n^3)$，但当函数 $w(l,r)$ 满足一些特殊的性质时，我们可以利用决策的单调性进行优化。

• 区间包含单调性：如果对于任意 $l\le l^{\prime }\le r^{\prime }\le r$，均有 $w(l^{\prime },r^{\prime })\le w(l,r)$ 成立，则称函数 $w$ 对于区间包含关系具有单调性。
• 四边形不等式：如果对于任意 $l_1\le l_2\le r_1\le r_2$，均有 $w(l_1,r_1)+w(l_2,r_2)\le w(l_1,r_2)+w(l_2,r_1)$ 成立，则称函数 $w$ 满足四边形不等式（简记为“交叉小于包含”）。若等号永远成立，则称函数 $w$ 满足 四边形恒等式。

引理 1：若 $w(l,r)$ 满足区间包含单调性和四边形不等式，则状态 $f_{l,r}$ 满足四边形不等式。

304. 诗人小G

2889. 再探石子合并

14. 插头DP

又叫轮廓线dp，是状态压缩dp的一种实现方式。一般都是基于一个网格，有连通性的限制。

2934. 插头DP

• 给你一个 $n\times m$ 的棋盘，有的格子是障碍，问共有多少条回路满足经过每个非障碍格子恰好一次。

• 每一个格子至多和上下左右四个格子相连，一条入边，一条出边，因此最多是6种经过这个格子的可能性。因此按照格子枚举复杂度比较低。我们从左到右，从上到下依次枚举格子，如图所示，红色线上方表示已经枚举过的格子，下方表示尚未枚举到的格子，红线拐弯的那个地方表示正在枚举的格子。我们看那个红线，表示边的信息。可以记录是否有边出来。然后记录连通块儿的信息，绿色的线连接的表示连通块儿。注意红线上每条小边也是有编号的，从 0 到 $N$ 共 $N+1$ 条边。

• $f(i,j,s)$ 表示当前枚举到第 $(i,j)$ 这个格子，轮廓线的状态是 $s$ 的方案数。用括号表示法的话（左括号表示连通块儿的左半边，右括号表示连通块儿的右半边），没有括号是0，左括号是1，右括号是2，红线上的每一条小边有3个状态，因此可以采用 4 进制表示这条红线的状态 s。而且我们也发现，枚举的 $(i,j)$ 的格子确定的话，方案数就确定了。

• 插头dp的状态表示都是这个样子，但是状态转移很复杂。插头dp最难的地方就是状态转移的讨论。

#include
#include
#include
using namespace std;
typedef long long ll;
const int maxn = 50010, maxm = maxn * 2 + 7;

//合法状态大致不到五万个

int N, M, end_x, end_y;  //end_x, end_y 表示最后一个没有障碍的格子
int g[20][20], q[2][maxn], cnt[maxn];  //滚动状态数组，q 里面存的是有效状态在哈希表内的下标。
int h[2][maxm];   //滚动哈希表
ll v[2][maxm];

int find(int cur, int x)   //哈希表
{
    int t = x % maxm;
    while(h[cur][t] != -1 && h[cur][t] != x){
        if(++t == maxm) t = 0;
    }
    return t;
}

void insert(int cur, int state, ll w)
{
    int t = find(cur, state);
    if (h[cur][t] == -1)
    {
        h[cur][t] = state, v[cur][t] = w;
        q[cur][++cnt[cur]] = t;
    }
    else v[cur][t] += w;
}

int get(int state, int k)   //求第 k 个格子的状态，其实就是求state的4进制的意义下第 k 位数字。
{
    return (state >> (k * 2)) & 3;
}

int set(int k, int v)   //构造四进制下第k位数字为 v 的数
{
    return v * (1 << (k * 2));
}

int main()
{
    scanf("%d%d", &N, &M);
    for(int i = 1; i <= N; i++){
        char str[20];
        scanf("%s", str + 1);
        for(int j = 1; j <= M; j++){
            if(str[j] == '.'){
                g[i][j] = 1;
                end_x = i, end_y = j;
            }
        }
    }
    ll res = 0;
    memset(h, -1, sizeof h);
    //将最开始的状态置为1
    int cur = 0;
    insert(cur, 0, 1);
    //cur表示滚动数组当前是哪一层。
    for (int i = 1; i <= N; i ++ )
    {
        for (int j = 1; j <= cnt[cur]; j ++ )
            h[cur][q[cur][j]] <<= 2;
        for (int j = 1; j <= M; j ++ )
        {
            int last = cur;
            cur ^= 1, cnt[cur] = 0;
            memset(h[cur], -1, sizeof h[cur]);
            for (int k = 1; k <= cnt[last]; k ++ )
            {
                int state = h[last][q[last][k]];
                ll w = v[last][q[last][k]];
                int x = get(state, j - 1), y = get(state, j);
                if (!g[i][j])
                {
                    //当前是障碍物
                    if (!x && !y) insert(cur, state, w);
                }
                else if (!x && !y)
                {
                    if (g[i + 1][j] && g[i][j + 1])
                        insert(cur, state + set(j - 1, 1) + set(j, 2), w);
                }
                else if (!x && y)
                {
                    if (g[i][j + 1]) insert(cur, state, w);  //状态不变
                    if (g[i + 1][j]) insert(cur, state + set(j - 1, y) - set(j, y), w);  //在j-1的位置减去插头y，在j的位置加上插头y
                }
                else if (x && !y)
                {
                    if (g[i][j + 1]) insert(cur, state - set(j - 1, x) + set(j, x), w);
                    if (g[i + 1][j]) insert(cur, state, w);
                }
                else if (x == 1 && y == 1)
                {
                    //开始括号匹配，找到最后一对匹配的括号，把他们俩连起来。
                    for (int u = j + 1, s = 1;; u ++ )
                    {
                        int z = get(state, u);
                        if (z == 1) s ++ ;
                        else if (z == 2)
                        {
                            if ( -- s == 0)
                            {
                                insert(cur, state - set(j - 1, x) - set(j, y) - set(u, 1), w);
                                break;
                            }
                        }
                    }
                }
                else if (x == 2 && y == 2)
                {
                    for (int u = j - 2, s = 1;; u -- )
                    {
                        int z = get(state, u);
                        if (z == 2) s ++ ;
                        else if (z == 1)
                        {
                            if ( -- s == 0)
                            {
                                insert(cur, state - set(j - 1, x) - set(j, y) + set(u, 1), w);
                                break;
                            }
                        }
                    }
                }
                else if (x == 2 && y == 1)
                {
                    insert(cur, state - set(j - 1, x) - set(j, y), w);
                }
                else if (i == end_x && j == end_y)
                    res += w;
            }
        }
    }
    printf("%lld\n", res);
    return 0;
}