各类动态规划

第一节：线性DP

思想：DP是作用在线性空间上的递推——DP的阶段按照各个维度线性的增长，从一个或多个边界点开始有方向的向整个状态空间转移扩展，最后在每个状态上保留的以自身为目标问题的最优解

简单的说，DP是不断划分自己的子问题（满足能从小问题推出大问题的答案），从最小的子问题开始一步步逼近目标点得到答案

DP实现的方式：

1.正序计算，

这里适用于最小的子问题可以直接得到解，且终态是一个确定的解。适用于大部分DP情况

2.倒序计算。

即我们知道终态的答案或者是由初始状态可以推出多个最终状态，此时就可以由终态反推回去。常用于数学期望的DP（期望性质：$E(ax+by)=aE(x)+bE(y)$）

3.记忆化搜索 常数略大于一般DP

  这里普遍用于DP在状态空间上的遍历很难直接用循环表示出来，或者说，不能用循环表示，此时一般使用记忆化搜索，多数用于图的DP

编写技巧

1.可以思考从当前答案向前推，亦或者用以前的答案求现在的答案两种形式，有些时候两种方式的实现复杂度会相去甚远

2.在DP的状态转移的时候，可以观察多重循环中相对内层循环的不变条件，以及内层循环的变量取值的域，对此可以适当的优化

比如LCIS这道题中，最后一层循环的k可以省去，因为k的取值在j+1时取值范围只会增大一，就可以省略最后一层，避免重复计算，观察决策集合随着外层循环的变化，若值增大不减小且限制条件不变，便可以只用一个变量来维护决策

3.注意挖掘题目中的维度，阶段

4.当DP涉及多个序列或者是连续性，需要序列末尾值的时候，可以将序列末尾的值当作一个状态存下（也可以用其他维度代表）

5.尽量地省略维度，在一个维度可以被其他维度表示出来的时候（这个关系往往需要去发现），就可以省掉这一维度

6.有些时候并不好确定DP的顺序，就可以使用贪心，topsort这些确定DP顺序，一般需要在题目里挖掘条件

7.缩放的艺术，当DP的f值只与前面的元素的相对关系有关的时候，就可以缩放状态，以保持相对关系不变性（比如所有都加一减一啥的）。。。比如ACwing277.饼干

8.当仅仅是题目中的维度不足以表示出整个状态，需要某些变量的时候，就可以找到某些变量将其也作为维度

9.需要注意DP时循环顺序应为：阶段->状态->决策

第二节——背包

01背包：

问题描述：有$n$个物品，其中第$i$个物品体积记作$V_i$,价值记作$W_i$,要求从中选出若干个，使得总体积不超过$M$，且价值和最大

模板：

int f[MAX_M];
memset(f,0xcf,sizeof f)l;
for(int i=1;i<=n;i++){
   for(int j=mj>=v[i]--j){//注意是倒序计算
   	f[j]=max(f[j],f[j-v[i]]+w[i]);
   }
}
int ans=0xcfcfcfcf;
for(int i=0i<=mi++)ans=max(f[i],ans);
                 

统计方案的时候把$\max$改成加

完全背包

问题描述：同01背包，但有无数个物品
板子:

int f[MAX_M];
memset(f,0xcf,sizeof f);
for(int i=1;i<=n;i++){;
   for(int j=v[i];j<=m;++j){//注意是正序计算
   	f[j]=max(f[j],f[j-v[i]]+w[i]);
   }
}
int ans=0xcfcfcfcf;
for(int i=0;i<=m;i++)ans=max(f[i],ans);
                 

解释:我们省略了第一维，所以倒序枚举的时候是建立在$i-1$的基础上的，而正序建立在$i$的基础上，就可以被重复计算
原因：二者二维递推式：

01背包

$$f_{i,j}=\max (f_{i-1,j},f_{i-1,j-v[i]}+w[i](j\ge v[i]))$$

完全背包

$$f_{i,j}=\max (f_{i-1,j},f_{i,j-v[i]}+w[i](j\ge v[i]))$$

多重背包

问题描述：有$n$种物品，每种有$C_i$个，其中第$i$种物品体积记作$V_i$,价值记作$W_i$,要求从中选出若干个，使得总体积不超过$M$，且价值和最大

思路

1.暴力拆他死了

2.二进制拆分
先上复杂度 $\Theta (nM\log E)$ 其中$E$是$C_i$的值域

思想：因为每一个数都可以表示为若干个二的整次幂(不重复)的和
所以我们可以计算出一个$p_i$满足:

$$2^0+2^1+\dots 2^p\le C_i$$

且这个$p$最大

此时我们就可以将$C_i$拆分成$p+2$个部分，即：
$2^0,2^1,2^2,\dots ,2^p,C_i-{\sum }_{i=0}^p{2}^i$,最后那个式子可以由等比数列求和公式改为:$C_i-2^{p+1}+1$

这样我们就可以把一共${\sum }_{i=1}^n{C}_i$个物品拆为少于$n\ast \log E$个物品，成功地掉了复杂度，一般已经够用

3.单调队列优化

见下：单调队列优化DP

分组背包

问题描述:给定$N$组物品，其中第$i$组有$C_i$个物品，其中第$j$个物品的体积为$V_{i,j}$,价值为$W_{i,j}$,有一容量为$M$的背包，要求选择若干个物品，使每组最多选择一个，且物品总体积小于$M$的情况下价值最大

还是以原始的二维DP，设 $fi,j$ 表示在前$i$选出总体积为$j$的物品放入背包的最大价值，有DP式：

$$f_{i,j}=\max (f_{i-1,j},\underset{1\le j\le C_i}{\max }{f}_{i-1,j-V_{i,k}}+W_{i,k})$$

同样的，省略第一维i,可得

memset(f,0xcf,sizeof f);
f[0]=0;
for(int i=1i<=ni++);
    for(int j=mj>=0j--);
	for(int k=1k<=c[i]k++);
     	    if(j>=v[i][k]);
                 f[j]=max(f[j],f[j-v[i][k]]+w[i][k]); 

这里需要注意的是

1.倒序循环$j$

2.对于每组物品的循环$k$应该放在$j$的内层，目的是如果放在外面因为一维数组所以可能变成多重背包

($i$是阶段,$i,j$构成状态，$k$是决策，应该按照$i,j,k$的顺序来)

区间DP

概念：关于序列上区间的DP问题

设计技巧：通常有两个维度l,r表示目前DP的区间，需要注意的是，必须如下这样写

for(int len=2len<=nlen++){
   for(int l=1,r=lenr<=nl++,r++){
   	……
   }
}

其目的是为了满足DP原则：先解决所有的小问题

在区间DP中，DP的阶段就是区间，使用两个区间端点l,r描述一个状态。同样是当前区间的答案为一些小区间的答案组合而来，所以我们DP的决策一般就是关于区间的划分。而区间DP的初始化一般就是对长度为1的"元区间"

同样的，在DP时，务必将阶段，状态，决策三者自外向内循环

在区间DP的过程中，决策一般就是区间划分，所以我们一般在关于第三层循环内循环k对区间进行划分统计

区间DP的编写技巧及注意事项：

1.对于带环状的区间，我们可以将$1\sim n$复制一倍接在后面形成一个$2n$的链，在其上进行统计，最后枚举所有长度为$n$的区间$[i,i+n-1](1\le i\le n)$

2.无论在什么时候，都要牢记动态规划的三原则三要素，时刻关注后效性和最优子结构性质

3.在自己进行区间DP时一定要反复问自己是否决策不完全

4.在两个序列合并的时候，最大值只有可能从1.两个序列最大值相加相乘，2.两个序列最小值相乘(负负得正) 3.一个序列的最大值乘另一个序列的最小值（两个序列都一正一负）。最小值同理

5.有时关于区间DP计数的时候，一定要注意不重不漏，关于DP的状态的设计，很多时候一些状态可以代表多个信息。在ACwing.284金字塔中，就有可能重复这时候我们让区间划分点k的含义[l,k]只能是第一颗子树，就不会重复也不会漏掉。。这里我们附加的这个信息必须具备2个性质:1.对所有的情形下都具有这个性质。2.必须满足不重不漏

6.在DP的方案统计的时候，如果一个状态的多个决策之间满足加法原理，而各个决策的方案又满足乘法原理时，在状态转移的时候各个决策必须具备互斥性才不会重复，对于互斥性的问题，我们可以挖掘题设条件，在DP的维度进行限制，比如改变某个维度的含义或者对这个含义进行缩小范围

7.当一般的$f[l,r]$并不能够维护好DP的信息的时候，我们观察题目数据范围，可以进行增加维度，如果时间复杂度过高则考虑优化或者换思路

8.在编写DP的时候，一定要注意当各个决策之间具有递归，嵌套性质的时候，在转移的时候就必须考虑之前的那些的嵌套关系，如AcWing.319折叠序列，我们使用KMP求出最小循环元之后，还得考虑这个最小循环元可不可以进行若干个拼凑起来的折叠，故我们得从最小循环元那里转移状态而不是直接用最小循环元算

树形DP

简述：在一颗树（通常是无根树，也就是$n-1$条边的无向图），我们可以任意拉一个节点为根节点，从而定义出节点的深度，根，子树大小等信息。在树上设计动态规划算法时，一般第一维为节点的编号，以节点由深到浅作为DP的阶段，树上的动态规划主要有两种形式：1.自顶向下的记忆化搜索。2.自底向上的topsort,其中绝大多数时候应用记忆化搜索。先递归子节点，回溯的时候进行状态转移

树形DP与背包

即有树形依赖的背包问题，例如AcWing.324

题意简述：给定一棵树，每个节点都有代价$W_i$，你可以选择节点$x$并付出$W_x$的代价得到$x$及$x$的子树,求得到$m$个节点的最小代价

我们发现，对于$u$，它的任意子节点$v$只能选择一个状态转移到$u$,这里就是一个分组背包模型
设$F[u][t]$表示在以$u$为根的子树中，选择$t$个节点的最小花费

这是一个背包模型：我们有$p=|Son(u)|$(u的子节点集合)组物品，每组物品有着$siz(x)$&nbsp&nbsp&nbsp&nbsp&nbsp$(x\in Son(u))$&nbsp&nbsp个，每组物品只能最多选择一个(因为只能有一个状态转移到父节点)，第$i$组第$j$个物品有着体积$V_{i,j}$和代价$W_{i,j}$,从中选出若干个物品，使得体积之和为$m$，并且代价最小

这里的状态转移方程就很好写了

$$F[u][t]=\underset{v\in Son(u)}{\min }\underset{0\le k\le \min (t,siz(v))}{\min }F[v][k]+F[u][t-k]$$

当然这个循环顺序还是按照阶段->状态->决策安排，即我们将$v$放在最外层，将$t$放在第二层（注意倒序），将$k$放在最里面

在最后我们还要考虑一下整体买整个子树的代价

即：$F[u][j]=\min (F[u][j],F[u][\max (0,j-siz(u))]+W_u)$

最后提一下本题其实是若干棵树，也就是一个森林，遇此情况我们一般都是建立一个虚拟节点0（统计答案时排除），将0作为森林中若干树的根节点的父亲最后在这颗新树上统计即可

void dp(int u){
	siz[u]=1;
	f[u][0]=0;
	for(int i=head[u];i;i=nxt[i]){
		int v=ver[i];
		dp(v);
		siz[u]+=siz[v];
	}
	for(int i=head[u]ii=nxt[i]){
		int v=ver[i];
		for(int t=siz[u]t>=0t--){
			for(int j=0j<=siz[v]++j){
				if(t>=j)f[u][t]=min(f[u][t-j]+f[v][j],f[u][t]);
			}
		}
	}
	if(u!=root){
		for(int i=0i<=siz[u]i++)f[u][i]=min(f[u][i],cost[u]);
	};
};

总结：其实也就是换汤不换药，背包的式子都没变，只是把以前的顺序枚举变成了枚举子树

顺带提一下，有一种方法，是把多叉树转为二叉树，以此更好编码统计，但不提倡，因为会耗费额外空间，并且容易混淆

二次扫描与换根法

适用范围：对于一类在无根树上的统计问题，需要枚举各个点为根节点进行统计的时候复杂度$O(n^{2}M)$,其中M是统计的额外操作时间，用此法可将复杂度消去一个$n$

思想阐述：第一次$dfs$,任选一个根节点$rt$，统计信息,第二次$dfs$借助第一次$dfs$的信息，这里假设我们以节点$u$为根时答案为$F_u$,则我们对每一个$v\in Son(u)$,因为$u->v$之间只有一条边的差异，所以我们可以在一般$O(1)$的时间内统计出将根节点从$u$改为$v$的时候对答案的影响(需要的信息需要在两次$DFS$中统计出来）从而计算出$F_v$再继续递归下去：

其本质仍然是充分利用已知信息，避免冗余计算

例如计算机此题

题意简述：给定一颗带权无根树，求出每个节点在树中距离最远的点

现在用二次扫描与换根法的思路来解决这个问题

首先我们先来分析我们从一个节点$u$转移到$v$,&nbsp&nbsp($v\in Son(u)$)的时候需要哪些信息：

设在树中距离节点$i$最远的节点为$f_i$

对于一个节点$u$的最长路有两种情况：在树中（$f_u$在$u$中）和不在树中(此时是$u$在$f_u$的子树中)

而对于$v$也有两种情况：$v$在u的最长路上(此时$f_u$必须在u的子树里)，$v$不在u的最长路上

而如果是第一种情况，转移的话需要知道$u$在树中的次长路，和$u$在树外的最长路，因为这两个值是有可能更新答案的

综上分析，我们需要维护三个信息:1.u在自家树中的最长路。2.u在自家树中的次长路。3.u在自家树外的最长路

其中信息1.2是可以在第一次$dfs$中找出来的，信息三的话，我们之前提到过：u在自家树外的最长路，此时u是在这个点的树里的，故我们可以在树自顶向下的时候统计求出

所以我们可以设$f_{u,0/1/2}$分别表示树内最长路，树内次长路，树外最长路，借此换根统计答案即可。

int dp(int u,int fa){;
    if(f[u][0]>=0)return f[u][0];
    f[u][0]=f[u][1]=f[u][2]=lst[u]=0;
    for(int i=head[u];i;i=nxt[i]){
        int v=ver[i],w=cost[i];
        if(v==fa)continue;
        if(f[u][0]<dp(v,u)+w){
            f[u][1]=f[u][0];
            f[u][0]=dp(v,u)+w;
            lst[u]=v;
        }
        else if(f[u][1]<dp(v,u)+w)
            f[u][1]=dp(v,u)+w;
    }
    return f[u][0];
}
void dfs(int u,int fa){
    for(int i=head[u];i;i=nxt[i]){
        int v=ver[i],w=cost[i];
        if(v==fa) continue;
        if(v==lst[u])f[v][2]=max(f[u][1],f[u][2])+w;
        else f[v][2]=max(f[u][0],f[u][2])+w;
        dfs(v,u);
    }
}

最后再次强调，我们在程序设计时，一定要有充分利用所有信息以及时间，空间

环形与后效性处理

环形处理：

即我们需要在一个环上进行DP

这种问题一般有两种处理方法

1.执行2次DP，在第一次DP时将问题随便找个点断开当成线性问题处理，第二次DP的时候通过对DP初始值的适当赋值，以及方程式及转移做出些许更改，保证计算出的代价等于把断开的点强制连上

2.将环断开，再复制一倍在末尾此时长度大于n的我们就不需要去考虑

两种方法要适当选择

第一种方法具有一定的局限性，即很多时候我们无法保证，这时候再采用法2，一般来讲在不付出额外代价的时候，方法一是更加优秀的

后效性处理

在一些题目中，题目解法神似DP，但却在我们列出了状态转移方程之后发现了有后效性，此做法就是关于后效性的处理：

使用前提：DP的三要素三前提只有无后效性不能满足，并且转移方程都是一次式，这样我们就可以将状态看作一个个未知数，通过状态转移方程的关系式直接用$Guass$消元求出方程的解。

但是一般题目不会如此直白(不然不就不考DP了嘛)，一般都是整体框架是DP，后效性只是局部型带环，这时候我们就需要大方向使用DP，在状态转移的时候才使用$Guass$消元求解

需要注意的是，因为状态转移方程都是简单的一次式，所以我们应该手动在草稿纸上将其移项，然后根据信息规律直接在代码里手动构建系数矩阵等等

例题：XOR和路径

题意简述：给定一个带权无向连通图（边权），上面有$1\sim n$个节点，从1开始编号。从 1 号节点开始，以相等的概率，随机选择与当前节点相关联的某条边，并沿着这条边走到下一个节点，重复这个过程直到走到 N 号节点为止，问一路上边权的异或和期望是多少

分析：发现由于异或的性质，我们直接处理并不怎么好处理，于是因为异或的按位不变性，以及数学期望是线性函数，我们可以对这个期望值进行按位计算

于是我们很容易可以得到状态转移方程：

设$F_u$表示在当前位下，$u\to n$的路径上异或值为$1$的概率，设$v$是$u$的子节点，$de{g}_u$表示$u$与u相连节点个数（即度）则

$$F_u=\left(\frac{1}{de{g}_u}\sum _{w(u,v)=0}{F}_v\right)+\left(\frac{1}{de{g}_u}\sum _{w(u,v)=1}\left(1-F_v\right)\right)$$

边界：$F_n=1$

因为这是一个无向连通图，所以这个状态转移方程是肯定有后效性的,这时候就需要我们上文说的高斯消元了

对这个式子进行一下变式，可得：

$$de{g}_u\times F_u+\sum _{w(u,v)=0}{F}_v-\sum _{w(u,v)=1}{F}_v=\sum _{w(u,v)=1}1$$

因为题目数据范围中$n\le 100$,所以我们可以将每一个$F$值全部作为未知数，这样我们按照状态转移方程就可以得到$n$个$n$元一次方程，运用高斯消元解即可

最后由于我们是按位计算的，所以第$i$位(从第0位开始)对答案的贡献是$2^i\times F_1$

具体实现：

#define int long long
#define db double 
db a[105][105],ans=0.0,eps=1e-8;
int tot,head[205],nxt[20005],ver[20005],cost[20005],deg[10005],n,m;
void add(int u,int v,int w){
	deg[u]++,nxt[++tot]=head[u],cost[tot]=w,ver[tot]=v,head[u]=tot;
}
db fabs(db a){
	return a<0?-a:a;
}
void swap(db &a,db &b){
	db c=aa=b,b=c;
} 
void init(int bit){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n+1;j++)a[i][j]=0.0;
	}
	a[n][n]=1;
	for(int u=1;u<n;u++){
		a[u][u]=deg[u];
		for(int i=head[u];i;i=nxt[i]){
			int v=ver[i];
			if(cost[i]>>bit&1)a[u][n+1]++,a[u][v]++;
			else a[u][v]-- ;
		}
	} 
}
void Guass(){
	for(int i=1;i<=n;i++){
		int p=0;
		for(int j=i;j<=n;j++){
			if(fabs(a[j][i])>eps){
				p=j	;
				break;
			}
		}
		if(!p)continue;
		for(int j=1;j<=n+1;j++)swap(a[i][j],a[p][j]);
		for(int j=1;j<=n;j++){
			if(j!=i){
				db rote=a[j][i]/a[i][i];
				for(int k=i;k<=n+1;k++){
					a[j][k]-=a[i][k]*rote;
				} 
			}
		}
	}
}
signed main(){
	scanf("%lld%lld",&n,&m);
	for(int i=1;i<=m;i++){
		int u,v,w;
		scanf("%lld%lld%lld",&u,&v,&w);
		add(u,v,w);
		if(u!=v)add(v,u,w);
	}
	for(int i=0;i<=50;i++){
		init(i);
		Guass();
		ans+=((1<<i)*a[1][n+1])/a[1][1];
	}
	printf("%.3lf",ans);
}

还有就是我们的状态转移方程很多时候会很特殊（因为高斯消元是$O(n^3)$的算法，从数据范围就可以发现端倪），这些系数矩阵列出来会比较特殊，比如上三角矩阵，只有对角线附近有元素的矩阵，或者说元素分布比较集中且每个方程里的未知数较少的时候，我们就可以对高斯消元算法进行一些改造，以此来加快速度

最后说一个深入理解的东西：即我们的DP其实都是对状态空间的遍历，而我们的DP如果是具有后效性其实就可以看作状态空间中存在环(本题中是一维DP，故状态空间是一张图)，而我们的高斯消元就是从代数层面去找环间的关系求出值，而如果从几何图论角度去看，我们也可以用找环的方式去消去后效性(SPFA),只不过此法实现比较复杂，且时间复杂度相同，使用较少，故略去

状态压缩DP

思想简述：DP的实质是在状态空间中的遍历，在部分题目中，DP在状态空间的轮廓需要我们很清晰的刻画出来，所以我们在DP过程中需要维护一个集合，来保存这个轮廓的详细信息。如果这个集合大小不超过$N$，并且都不超过$K$，我们就可以用一个$N$位$K$进制数来保存这个集合，用一个$[0,N^K-1]$的十进制整数来存这个集合。这种将集合化为$K$进制数，作为DP的一维的动态规划算法被称作状态压缩动态规划，当然其他维度我们就存储比如当前节点，上一个节点之类的

如何发现可以用状压DP：

1.数据$N,M$在$[10,20]$的时候可以考虑状压DP算法

2.有明显的动态规划特征且数据较小

复杂度：一般若采用$k$进制数，复杂度为$O(n{k}^n)$这只是一个下界

图形填充问题

来道经典的例题吧

AcWing.328芯片

题意简述：

给定一张$N\times M$的图，其中有一些方格不可以放置，求最多可以放置多少个$2\times 3$的矩形(可以横着放也可以竖着放)

这里因为竖着放是联系了上下三格的，所以为了代码的好写，我们使用三进制状态压缩

好的那么我们因为是矩形，我们可以规定2，1，0分别表示矩形的3,2,1层，那么$2\times 3$的矩形和$3\times 2$的矩形可以分别表示为：

$$\begin{array}{ccc}1& 1& 1\\ 0& 0& 0\end{array}$$

$$\begin{array}{cc}2& 2\\ 1& 1\\ 0& 0\end{array}$$

此时我们就可得到一个动态规划算法：

设$F_{i,j}$表示第$i$行填写状态为$j$时，放置矩形的最多数量

每一个状态需要满足:

1.坏掉的格子只能填0

2.2的下面必须填1，1的下面必须填0

由于状态转移方程比较复杂，我们可以采用另一种实现方式：搜索

具体的：我们对于每一行分别搜索,对其按上述原则进行试填,填完后就得到一个状态,对这个状态更新答案即可

目标$F_{n,0}$

由于每一行的状态只与上一行有关，所以我们需要使用滚动数组优化空间

$Code$

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int pow[15],a[155][155],n,m,f[2][200000];
void init(){
	pow[0]=1;
	for(int i=1;i<=14;i++)pow[i]=pow[i-1]*3;
}//这个操作很重要，是进行k进制运算的基础操作
int find(int x,int y){
	return x%pow[y]/pow[y-1] ;
}
bool check(int x,int y,int last){
	return !a[x][y]&&!find(last,m-y+1); 
}
void dfs(int x,int last,int now,int pos,int cnt){
	if(!pos){
		f[x&1][now]=max(f[(x+1)&1][last]+cnt,f[x&1][now]);
		return ;
	}
	if(find(last,pos)){
		if(a[x][m-pos+1])return ;
		dfs(x,last,now*3+find(last,pos)-1,pos-1,cnt);
		return ;
	}
	dfs(x,last,now*3,pos-1,cnt);
	if(pos>=2&&check(x,m-pos+2,last)&&check(x,m-pos+1,last))dfs(x,last,(now*3+2)*3+2,pos-2,cnt+1);
	if(pos>=3&&check(x,m-pos+3,last)&&check(x,m-pos+2,last)&&check(x,m-pos+1,last))dfs(x,last,((now*3+1)*3+1)*3+1,pos-3,cnt+1);
}
int main(){
	int k;
	init();
	int d;
	scanf("%d",&d);
	while(d--){
		scanf("%d%d%d",&n,&m,&k);
		memset(a,0,sizeof a);
		for(int i=1;i<=k;i++){;
			int x,y;
			scanf("%d%d",&x,&y);
			a[x][y]=1;
		} 
		memset(f,0xcf,sizeof f);
		f[0][0]=0;
		for(int i=1;i<=n;i++){
			for(int j=0j<pow[m]j++)f[i&1][j]=0xcfcfcfcf;
			for(int j=0j<pow[m]j++){
				if(f[(i-1)&1][j]>=0)dfs(i,j,0,m,0) ;
			}
		}
		printf("%d\n",f[n&1][0]);
	}
}

技巧与总结:
1.使用滚动数组优化空间
2.使用三进制，分清每一个数的代表含义
3.在无法填的地方填0不会影响答案
4.注意到a数组是顺序存，而dfs是从右往左

还有一些实现技巧：

1.当我们不是使用搜索而是使用朴素DP的时候，我们对于不可以填的格子也可以储存成一个k进制数，当判断的时候我们只需要一个按位&运算，当结果为0的时候就代表这个状态没有填到不可以填的位置上

2.多进制常数较大，所以常用二进制

总结一下图形填充问题的套路：

我们填充的图形都与若干行有关，所以很容易的我们就可以按照行号划分阶段，然后我们观察图形的特征(只考虑当前行及以前行的即可)，以此来将图形按照行列寻找限制条件（题目本身限制也算），此时我们观察填充这个图形一共需要几个状态（一般我们以行为阶段，则有多少行就需要几进制数），这时候我们也可以通过一些奇淫技巧将进制数降低（比如动态规划的时候多加一个维度去存储$i-1$行的信息）综合时间空间以及编码难度来选择合适的DP方法

还有就是，有些时候，状态转移方程不容易定义出来，只能提炼出一个个限制条件，这时候因为有限制条件的存在，我们可以把这一轮DP换成搜索，反正时间复杂度也不会差，还能降低很多编码难度

然后再来两道其他类型的状压DP

AcWing.529宝藏

题意简述：给定一个无向连通图，有N个节点M条边，我们需要找到一个节点K,以K为根将这张图拉成一棵树，然后对于树中的每个节点$i$我们需要付出代价：$i$的深度-1（根节点深度为1）乘上$i$到其父节点的边的边权，求一个使代价最小的K并输出这个最小代价（$n\le 12,m\le 1000$）

分析：

看到题目的一瞬间，一个词蹦出来了：二次扫描与换根，很可惜，这道题牵一发而动全身，这样做是不可以维护换根操作的，所以它死了

看到$n\le 12$，很容易猜到这是一道状压

分析

解法1：二进制状态压缩

我们考虑：因为我们确定了根节点之后整棵树的代价也就确定了，以至于这个根节点就构成了DP的阶段。但是很显然，这个阶段并不具备有序性，所以它死了

对于此题我们发现：这些代价的计算与他们的深度有关系，所以我们不妨设:

$F[i][j]$表示在前i层状态为j(每一位的0表示没，1表示有)时代价的最小值

定义函数：

1.$valid(k,j)$表示状态k增加若干条道路可以扩展为状态j且只扩展一层

2.$cost(k,j)$表示由状态k扩展为状态j增加的道路的路长总和的最小值

3.$expend(k)$表示由状态k扩展一层所得到的所有点的集合（包括k）

4.$road(k,x)$表示从k中扩展一层打通到节点x的道路长度的最小值

则有DP方程式:

$$F[i][j]=\underset{valid(k,j)}{\min }\left(F[i-1][k]+(i-1)\times cost(k,j)\right)$$

其中首先我们看valid函数怎么求

满足$valid$函数为真的充要条件是$k$是$j$的子集且$j$是$expand(k)$的子集

即j & k=k,&nbsp&nbsp&nbspexpand(k) & j = j

函数$expand$我们可以通过一次扫描节点得到，顺带就扣以求出$road$

至于$cost$的求法，就只需要在扫描一次，就扣以了

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=15,M=1<<12;
int n,m;
int a[N][N],f[N][M];
int expand[M],road[M][N];
vector<int>vaild[M],cost[M];
/*
vaild[i][j]表示由j状态扩展一层可以得到i
cost[i][j]表示j状态变为i状态的最短道路总长 
road[i][j]表示从i状态扩展到j节点的最短路
expand[i]表示i状态多扩展一层得到的状态集合 
*/ 
void init(){
	memset(road,0x3f,sizeof road);
	for(int k=0;k<1<<n;k++){
		expand[k]=k;
		for(int j=1;j<=n;j++)
			if(k>>(j-1)&1){
				road[k][j]=0;
				for(int i=1;i<=n;i++)
					if(a[i][j]!=0x3f3f3f3f){
						expand[k]|=(1<<(i-1));
						road[k][i]=min(road[k][i],a[i][j]);
					}
			}
	}
	for(int j=0;j<1<<n;j++)
		for(int k=0;k<j;k++)
			if((k&j)==k&&(expand[k]&j)==j){
				vaild[j].push_back(k);
				int sum=0;
				int q=j^k;
				for(int i=1;i<=n;i++)if(q>>(i-1)&1)sum+=road[k][i];
				cost[j].push_back(sum);
			}
} 
int main(){
	scanf("%d%d",&n,&m)
	memset(a,0x3f,sizeof a);
	for(int i=1;i<=m;i++){
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		a[u][v]=a[v][u]=min(a[u][v],w);
	}
	init();
	memset(f,0x3f,sizeof f);
	for(int i=1i<=ni++)f[1][1<<(i-1)]=0;
	int ans=f[1][(1<<n)-1];
	for(int i=2;i<=n;i++){
		for(int j=1;j<1<<n;j++){
			int lenj=vaild[j].size();
			for(int k1=0;k1<lenj;k1++){
				int k=vaild[j][k1];
				f[i][j]=min(f[i-1][k]+(i-1)*cost[j][k1],f[i][j]);
			}
		}
		ans=min(ans,f[i][(1<<n)-1]);
	}
	printf("%d\n",ans);
}

当然其实这份代码是有问题的，但这个问题对答案并无影响，就是在k状态转移的时候我们无法知道k中到底是哪些节点是第i-1层的，哪些是更小的，但是这个并不影响答案，因为更小意味着更早扩展，这个答案早就被其他状态计算了，并不会影响最小值的计算，这也是最优化问题的常用等效手法

解法二 三进制状压

例题三：

AcWing1194岛和桥

题目：

给定一个地图，地图中包含很多岛和连接它们的桥。

汉密尔顿路径是指沿着桥访问每个岛屿恰好一次的路径。

在我们的地图上的每个岛都具有一个权值，它是一个正整数。

假设一共有 $n$ 个岛，第 i 个岛的权值为$V_i$。

现在规定一个汉密尔顿路径的总价值为以下三个价值的和：

每个岛屿的权值之和。

汉密尔顿路径中，每一条边连接的相邻岛屿的权值乘积之和。

如果在汉密尔顿路径中存在相邻的三个岛屿可以构成环形，则将所有满足条件的相邻岛屿三元组权值的乘积相加求和。

任务一：请你找出汉密尔顿路径的总价值最大可以为多少。

任务二：请你找出满足最大总价值的汉密尔顿路径共有多少条。

分析：在这道题中，第一个价值直接无视，第二个价值我们可以维护二维状压DP记录两个相邻岛，第三个价值就需要我们在状压中记录当前节点，上一个节点，然后在转移的时候的下一个节点判断一下是否构成环即可

对于任务一就可以直接状压解决，任务二的话就对每一个状压状态开一个计数数组统计的时候加起来就行,为了更好处理，这里我们把节点从0开始编号

具体的我们设
$F[i][j][a]$表示状态为a，当前节点为j，上一个节点为i时的最大价值

我们采用以当前状态更新的策略：

$$F[j][k][a|(1<<k)]=\min (F[j][k][a|(1<<k)],F[i][j][k]+road[i][j][k])$$

其中$road[i][j][k]$表示i是路径中的一个很老的点，j和k构成路径的价值，以及判断i,j,k是否为环的价值

所以我们可以预处理出road，这样就很容易得出解

实现技巧:由于N极小，所以可以直接邻接矩阵存图

const int N=15,M=1<<13;
int f[N][N][M],cnt[N][N][M],n,m,T,val[N] ;
bool check[N][N];
int road[N][N][N] ;
int main(){
	int t;
	scanf("%d",&t);
	while(t--){
		memset(cnt,0,sizeof cnt);
	  memset(f,0xcf,sizeof f);
	  memset(check,0,sizeof check);
	  memset(road,0,sizeof road);
		scanf("%d%d",&n,&m);
		for(int i=0;i<n;i++)scanf("%d",&val[i]);
		for(int i=1;i<=m;i++){
			int u,v;
			scanf("%d%d",&u,&v);
			v--,u-- ;
			check[u][v]=check[v][u]=1;
		}
		for(int i=0;i<n;i++)f[i][i][1<<i]=val[i],cnt[i][i][1<<i]=1;
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				for(int k=0;k<n;k++){
					road[i][j][k]+=val[j]*val[k]+val[k];
					if(check[i][j]&&check[j][k]&&check[k][i])road[i][j][k]+=val[i]*val[j]*val[k];
				}
			}
		}
		for(int a=0;a<1<<n;a++){
			for(int i=0;i<n;i++){
				for(int j=0;j<n;j++){
					for(int k=0;k<n;k++){
						if(a>>k&1||!check[j][k])continue;
						if(f[j][k][a|(1<<k)]<f[i][j][a]+road[i][j][k]){
							f[j][k][a|(1<<k)]=f[i][j][a]+road[i][j][k];
							cnt[j][k][a|(1<<k)]=cnt[i][j][a];
						}
						else if(f[j][k][a|(1<<k)]==f[i][j][a]+road[i][j][k]){
							cnt[j][k][a|(1<<k)]+=cnt[i][j][a];
						}
					}
				}
			}
		}
		int ans=0xcfcfcfcf,sum=0;
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				if(f[i][j][(1<<n)-1]>ans){
					sum=cnt[i][j][(1<<n)-1];
					ans=f[i][j][(1<<n)-1];
				}
				else if(f[i][j][(1<<n)-1]==ans) {
					sum+=cnt[i][j][(1<<n)-1];
				}
			}
		}
		if(ans<0){
			puts("0 0");
			continue;
		}
		printf("%d %d\n",ans,sum/2);
	}
	return 0
}

DP优化部分
由于篇幅过大，已经搬出

计数DP

顾名思义，这是对于方案统计的DP类型

需要记住的公式：

1. 在平面直角坐标系中，从点$(x_1,y_1)$走到$(x_2,y_2)$，$(x_1<x_2,y_1,<y_2),$每一步只能使得$x_1+1$或者是$y_1+1$，求合法路径的条数为：
   $$C_{x_2-x_1+y_2-x_1}^{x_2-x_1}=C_{x_2+y_2-x_1-y_1}^{y_2-y_1}$$

证明：因为每一步只能向右或者向上走，所以我们可以把每一步抽象为一个物品，共有$x_2+y_2-x_1-y_1$个，从中选出向右走的$x_2-x_1$个或者向上走的$y_2-y_1$个，由组合数的定义即得

2. 一张含有$n$个节点的无向图一共有$2^{n\ast (n-1)/2}$种可能性(节点不编号)
3. 一张含有$n$个节点的连通无向图(节点有编号)，一共有的可能性数量为：
   $$f[i]=2^{i\ast (i-1)/2}-\sum _{j=1}^{i-1}f[j]\ast C_{i-1}^{j-1}\ast 2^{(i-j)\ast (i-j-1)/2}=\sum _{k=1}^{i-1}{C}_{i-2}^{k-1}\ast f[k]\ast f[i-k]\ast (2^k-1)(i\ge 3)$$
       初值：$f[1]=1$
4. 一张含有$n$个节点,$j$条割边，且无重边和自环的无向连通图图一共有的可能性数量为：
   设$f[i,j]$表示有$i$个点$j$条割边的无向连通图，有公式：
   $$f[i,j]=\sum _{k=1}^{i-1}\left(f[k,0]\ast C_{i-1}^{k-1}\ast \sum _{x=1}^{\min (i-k,j)}\left(G[i-k,x,j-x]\ast k^x\right)\right)$$

其中$G[i,j,k]$表示由$i$个点构成的，含有$j$个连通块，$k$条割边的无向图总数

有公式;
$$G[i,j,k]=\sum _{p=1}^i\sum _{q=0}^k\left(f[p,q]\ast G[i-p,j-1,k-q]\ast p\ast C_{i-1}^{p-1}\right)$$
    初值：$f[k,0]=H[i]-{\sum }_{j=1}^{k-1}f[k,j]$,其中
$$H[i]=2^{i\ast (i-1)/2}-\sum _{j=1}^{i-1}H[j]\ast C_{i-1}^{j-1}\ast 2^{(i-j)\ast (i-j-1)/2}=\sum _{k=1}^{i-1}{C}_{i-2}^{k-1}\ast H[k]\ast H[i-k]\ast (2^k-1)(i\ge 3)$$
5. 在一个长度为n的环里，可以交换任意两个节点，使得这个环变为n个自环且使用最少步骤的方案有$f[n]=n^{n-2}$
下面的例题中会详细推导这一整个公式，并附上代码

注意事项：

1. 之前提到过的：在DP的方案统计的时候，如果一个状态的多个决策之间满足加法原理，而各个决策的方案又满足乘法原理时，在状态转移的时候各个决策必须具备互斥性才不会重复，对于互斥性的问题，我们可以挖掘题设条件，在DP的维度进行限制，比如改变某个维度的含义或者对这个含义进行缩小范围

2. 擅长从正反两面思考问题，如果正着不好处理，不妨采用总-反的方式，这是弱化版的容斥原理

3. 合理运用组合计数公式以及容斥原理等，记得有时可以打表找感觉

4. 十年OI一场空，不开longlong见祖宗

5. 注意方案之间的重复性，一定得做到不重不漏

6. 在实现代码设计状态的时候可以使用等效转换，将问题变得更容易统计，一般是在不影响答案的情况下将绝对性表述换为相对性表述

7. 注意方案之间的内在联系，方案之间也可以求排名，求排名的时候需要像平衡树那样把小的一坨全删了，具体见装饰围栏

套路

1. 思路1：为了不重不漏，在计数DP的设计中，我们会经常使用围绕一个（或者是两个）基准点，构造一个不可划分的整体，对此进行计算(见例1)
2. 思路2：构造法，将需要的构造出来，见例2
3. 一般需要复杂度$O(lo{g}_n)\sim O(nlogn)$的是数学题，复杂度$O(n^2+)$是DP题
   下面就开题了：

例题：How many of them

题目描述
在无向连通图中，若一条边被删除后，图会分成不连通的两部分，则称该边为割边。

求满足如下条件的无向连通图的数量：

1、由 N 个节点构成，节点有标号，编号为 1∼N。

2、割边不超过 M 条。

3、没有自环和重边。

熟悉不，这就是我们之前提到的第四条公式，下面展开详细推导

首先我们先讨论$j>0$时的做法，很明显，我们可以以1号节点为基准点进行思考

在图论中，我们称不含割边的图为双连通分量，很明显，一个含有割边的无向图一定有着双连通分量
所以我们先来考虑当节点1处于一个大小为$k$的双连通分量的时候共有多少方案，很明显，从剩下的$i-1$个节点里拿$k-1$个就行，即$f[k,0]\ast C_{i-1}^{k-1}$,当我们去掉了这个双连通分量之后，剩下的图形一共就有$G[i-k,x,j-x]$种，其中$x$是小于$\min (i-k,j)$的正整数，因为这个双连通分量一旦删去，与他相连的其他连通块的边就是割边，又因为这个双连通分量的大小为$k$，剩下了$x$个连通块，所以每一个连通块都可以连接双连通分量中的$k$个节点，由乘法原理得到共有$k^x$种，综上所述，我们得到了这样一个递推式：($0<j<i$)
$$f[i,j]=\sum _{k=1}^{i-1}\left(f[k,0]\ast C_{i-1}^{k-1}\ast \sum _{x=1}^{\min (i-k,j)}\left(G[i-k,x,j-x]\ast k^x\right)\right)$$
而当$j=0$时，我们可以这样想，即在一个有着$n$个节点(节点编号)的无向连通图减去含有割边的无向连通图数量就得到了不含割边的无向连通图数量，而有着n个节点的无向连通图数量在公式3中已经给出，在公式4里体现为$H$，于是我们得到了
$$f[k,0]=H[i]-\sum _{j=1}^{k-1}f[k,j]$$
，现在我们来讨论$G[i,j,k]$的求法：我们仍然以1号节点为基准点，对其进行操作，不妨思考，对于这样一张无向连通图，我们可以枚举一号节点所在的连通块的割边数量($q$)和大小($p$)这样一共有$f[p,q]$种方案，然后由乘法原理，再乘上$G[i-p][j-1][k-q]$，在这里不能忽略了我们选出这$p$个节点一共有$C_{i-1}^{p-1}$种方法，并且我们还需要从这个连通块里面选出一个节点与我们剩下的图相连，很明显有$p$种，于是我们得到了：

$$G[i,j,k]=\sum _{p=1}^i\sum _{q=0}^k\left(f[p,q]\ast G[i-p,j-1,k-q]\ast p\ast C_{i-1}^{p-1}\right)$$

代码贴一份，这题时间紧，这份代码常数较大最后两个点过不了，预处理一下组合数(递推)，取消#define int long long，再预处理一下2的幂，在代码中处理$k^x$的时候直接循环，不要快速幂，这样就可以过了，不过我懒，懒得，以至于复杂度加了个log，常数还大得惊人，以至于没了

#include<iostream>
#include<cstdio>
using namespace std;
#define int long long
int f[55][55],g[55][55][55],jc[55],inv[55],h[55],p=1e9+7,n,m;
int power(int a,int b){
	int ans=1;
	while(b){
		if(b&1)ans=ans*a%p;
		a=a*a%p;
		b>>=1;
	}
	return ans;
}
void init(){
	inv[0]=jc[0]=1;
	for(int i=1;i<=n;i++)jc[i]=jc[i-1]*i%p,inv[i]=power(jc[i],p-2)%p;
} 
int C(int n,int m){
	return jc[n]%p*inv[m]%p*inv[n-m]%p;
}
signed main(){
	scanf("%lld%lld",&n,&m);
	g[0][0][0]=1;
	init();
	for(int i=1;i<=n;i++){
		h[i]=power(2,i*(i-1)/2);
		for(int j=1;j<i;j++){
			h[i]=(h[i]-h[j]*C(i-1,j-1)%p*power(2,(i-j)*(i-j-1)/2)%p)%p;
		}
		f[i][0]=h[i];
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<i;j++){
			for(int k=1;k<i;k++){
				int s=0;
				for(int x=1;x<=min(i-k,j);x++)s=(s+g[i-k][x][j-x]*power(k,x)%p)%p;
				f[i][j]+=f[k][0]*C(i-1,k-1)%p*s%p;
			}
			f[i][0]=((f[i][0]-f[i][j])%p+p)%p;
		}
		for(int j=1;j<=i;j++)
			for(int k=0;k<i;k++)
				for(int p1=1;p1<=i;p1++)
					for(int q=0;q<=k;q++)
						g[i][j][k]=(g[i][j][k]+f[p1][q]*C(i-1,p1-1)%p*p1%p*g[i-p1][j-1][k-q])%p;
	}
	int ans=0;
	for(int i=0;i<=m;i++)ans=(ans+f[n][i])%p;
	printf("%lld",(ans%p+p)%p);
}

例题：扑克牌

题面描述：
一副不含王的扑克牌由 52 张牌组成，由红桃、黑桃、梅花、方块 4 组牌组成，每组 13 张不同的面值。

现在给定 52 张牌中的若干张，请计算将它们排成一列，相邻的牌面值不同的方案数。

牌的表示方法为 XY，其中 X 为面值，为 2、3、4、5、6、7、8、9、T、J、Q、K、A 中的一个。

Y 为花色，为 S、H、D、C 中的一个。

如 2S、2H、TD 等。
有T组数据，每组数据有N张牌，时间限制1s
$1\le T\le 20000,1\le N\le 52$
分析：在此题中，我们设$a_i$表示第i种牌花色的牌的数量，$b_i$表示面值，很容易想到一个$O(n{a}_i^{b_i})$的暴力DP，可惜不可以，于是我们继续挖掘题目条件，一定还有优化的余地
我们发现，

1. 题目上的限制仅仅是两个不同而已，于是乎我们并不关心两者的具体权值，只关心是不是相等
2. 每种牌的数量很少，这启发我们构建一个以牌的数量为状态的状态转移方程
3. 同类牌是可以互相交换的

这题的难度就在状态的设计
因为未使用的牌的数量只有可能为$1,2,3,4$，于是我们可以设置四个维度的状态，分别表示还有多少种牌剩下一张的，两张的…，又由于四维状态并不好满足限制条件：相邻两个不能相同，于是我们又增加一维，记录上一次是从剩下几张牌的堆里面转移过来的。状态转移方程就昭然若揭
设$f[a,b,c,d,e]$表示有a种剩余一张的牌，b种剩余两张的牌，c种剩余3张的牌，d种剩余四张的牌，上一次是从剩余e张牌的堆里拿出来的，有方程(代码形式，数据较大得开ull)：

ull ask(int a,int b,int c,int d,int e){
    ull& res=f[a][b][c][d][e];
	if(res)return res;
    if(a)res+=ask(a-1,b,c,d,1)*(a-(e==2))；
    if(b)res+=ask(a+1,b-1,c,d,2)*2*(b-(e==3));
    if(c)res+=ask(a,b+1,c-1,d,3)*3*(c-(e==4));
    if(d)res+=ask(a,b,c+1,d-1,4)*4*d;
    return res;
}

我们以第一部分为例讲解状态转移方程是怎么来的
$f[a,b,c,d,e]+=f[a-1,b,c,d,1]\ast (a-(e=2))$
由于我们是按照记忆化搜索的形式实现的自顶向下的动态规划，于是我们令上一次的状态为$f[a^{\prime },b^{\prime },c^{\prime },d^{\prime },e^{\prime }]$
对于我们第一个方程，当$e=2$时，很明显$a=a^{\prime }+1,b=b^{\prime }-1$（由第二部分转移方程得到），于是我们这个转移方程也可以写作
$f[a,b,c,d,e]+=f[a^{\prime },b^{\prime }-1,c,d,1]\ast (a-(e=2))$
我们会发现，之所以我们的判断条件是$e=2$，是因为e是反应的上一步的决策，现在我们以$a^{\prime },b^{\prime }$的形式写出来之后决策是拿走第二堆的牌，于是$e=2$,剩下的几个部分同理，当$e=2$时，我们之所以乘上$a-1$就是因为我们需要使用容斥原理消去“两个相邻的不能在一起”这个影响，因为数量为2的牌的堆被拿走了一个，这个在一种情况下与之前的相同的牌挨在一起了，需要消去，同理，e=3的时候会加进去同种牌的一个，那种牌剩下两张，于是共会产生两种可能的冲突，e=4时同理，当然，当e=1的时候就不用管了，那时候都没牌了，第四部分的方程也不用管，那种牌都没拿走过
由于状态转移方程比较复杂，循环形式难以实现，故采用递归实现

#include<iostream>
#define ull unsigned long long
using namespace std;
int n,t,val[75],cnt[5],num[55],tot;
ull f[15][15][15][15][5];
char s[1005];
ull ask(int a,int b,int c,int d,int e){
    ull& res=f[a][b][c][d][e];
	if(res)return res;
    if(a)res+=ask(a-1,b,c,d,1)*(a-(e==2))；
    if(b)res+=ask(a+1,b-1,c,d,2)*2*(b-(e==3));
    if(c)res+=ask(a,b+1,c-1,d,3)*3*(c-(e==4));
    if(d)res+=ask(a,b,c+1,d-1,4)*4*d;
    return res;
}
signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
    for(int i=0;i<=4;++i)f[0][0][0][0][i]=1;
    int res=0;
    cin>>t;
    while(t--){
        cin>>n;
        for(int i=1;i<=n;++i)cin>>s,++val[s[0]-49];
        for(int i=1;i<=4;++i)cnt[i]=0;
        for(int i=0;i<=50;++i)++cnt[val[i]],val[i]=0;
        cout<<"Case #"<<++res<<": "<<ask(cnt[1],cnt[2],cnt[3],cnt[4],0)<<"\n";
    }
    return 0;
}

以上就是计数DP的内容，以后有更多内容的时候再补

数位统计DP

数位统计DP是一种有关数字的限制问题，一般问题形式类似于给定若干限制条件，求满足条件的第K小的数是多少，或者是询问区间$[L,R]$内有多少满足要求的数字，对于这种类型的题，我们一般是先使用动态规划进行预处理，再运用类似与倍增优化DP的拼凑思想拼出最后的答案，亦或者是试填法
在这类题中，我们动态规划的状态设计一般是第一维是第$i$位数字，也就是阶段，后面几个维度一般是题目给的限制条件诞生的维度。
在做题过程中，这类型的题数据范围一般较大，但我们动态规划的算法复杂度大约为$O({\log }^{k}N)$，至于拼凑与试填法的复杂度也是对数级别。这里的题很多与数学问题有所交叉，可以留意一下

做题套路

1. 第K大，遇到这种问题的一般步骤是：动态规划预处理，再使用试填法，这个过程从高位考虑到低位，考虑当前位有多少种选择，填了当前位置之后有多少种方案(排名)，类似于平衡树求排名，我们从小到大枚举每一位的可能性，当我们可以填i的时候，如果填i之后的方案数不够K，那么i就不可以填，此时还要令K-=填i的方案数，注意一定得减，当找到的第一个方案数大于k的，这个方案就是我们应该选择的方案。这个的原理我们可以把整个所有的可能性看成一颗搜索树，每一个节点上都存着它有多少个叶子节点(对应方案数),我们要在这棵搜索树里找到从树根到排名为K的叶子节点的路径就是我们的答案,就与平衡树，权值线段树类似
2. 求区间$[L,R]$，这里因为是关于数的统计问题，是无后效性的，于是我们可以将其转换为前缀和运算,同样的，先进行动态规划预处理，用某些标志性的点进行拼凑出答案，当然我们也可以使用试填法的思想，只不过这个变成了统计方案而已

注意事项

1. 时刻注意前导零的处理
2. 强调不重不漏性
3. 注意到动态规划的维度等等不要冗余

实战

例题1：装饰围栏

题目描述：

有 $N$ 块长方形的木板，长度分别为 $1,2,\dots ,N$，宽度都是$1$。

现在要用这 $N$ 块木板组成一个宽度为 $N$ 的围栏，满足在围栏中，每块木板两侧的木板要么都比它高，要么都比它低。

也就是说，围栏中的木板是高低交错的。

我们称“两侧比它低的木板”处于高位，“两侧比它高的木板”处于低位。

显然，有很多种构建围栏的方案。

每个方案可以写作一个长度为 $N$ 的序列，序列中的各元素是木板的长度。

把这些序列按照字典序排序，如下图所示，就是 $N=4$ 时，所有满足条件的围栏按照木板长度的字典序排序后的结果。

现在给定整数 C，求排名为 C 的围栏中，各木板的长度从左到右依次是多少。
$1\le N\le 20,$
$0<C<2^{63}$

分析

很明显，N很小，C很大，这是一个第K大问题，我们按照套路来处理

1. 设计动态规划：由于N很小，我们设计一个与N相关的状态，又因为这个涉及到高低排名，于是：设$f[i,j,k]$表示用$i$块木板，其中最左边木板的排名为$j$，身处$k$位(0低1高)的方案数，注意这里我们采用了类似排名的描述，而不是像长度为j这样的绝对性描述，这是因为在$1\sim N$中，排名为j和长度为j是等价的，且运用排名会使得我们状态转移非常轻松
2. 进行动态规划预处理：有状态转移方程：
   $$f[i,j,0]=\sum _{p=j}^{i-1}f[i-1,p,1]\text{，}f[i,j,1]=\sum _{q=1}^{j-1}f[i-1,q,0]$$
3. 进行拼凑，具体步骤为：
   (1). 假设我们已经填好了$i-1$块木板，记上一块木板的长度为$last$，位于$k$位，现在我们来考虑第$i$块木板
   (2). 将$k$改为$k\oplus 1$即可得到当前木板的状态，然后我们从小到大枚举当前木板的实际长度和相对排名，尝试着使用这一个方案进行下一步
   (3).设我们枚举的实际长度为$len$，相对排名为$j$，若$f[n-i+1,j,k]<C$,令$C=C-f[n-i+1,j,k]$，继续尝试更大的$j$，否则这个$j$就是我们第$i$位的答案，进行下一位的枚举，直到最后就得出了答案，当然，最初的计算我们就直接判断$k=0/1$谁可以就可以了
   $$\mathrm{Code}$$

#define int long long
int t,f[25][25][2],n,m,vis[25];
void init(){
	f[1][1][0]=f[1][1][1]=1;
	for(int i=2;i<=20;i++)
		for(int j=1;j<=i;j++){
			for(int k=1;k<j;k++)f[i][j][1]+=f[i-1][k][0];
			for(int k=j;k<i;k++)f[i][j][0]+=f[i-1][k][1];
		}
}//DP预处理
signed main(){
	init();
	scanf("%lld",&t);
	while(t--){
		scanf("%lld%lld",&n,&m);
		memset(vis,0,sizeof vis);
		int last,k;
		for(int j=1;j<=n;j++){
			if(f[n][j][1]>=m){
				last=j;
				k=1;
				break;
			}
			else m-=f[n][j][1];
			if(f[n][j][0]>=m){
				last=j;
				k=0;
				break;
			}
			else m-=f[n][j][0];
		}//枚举第一位的情况
		vis[last]=1;
		printf("%lld",last);
		for(int i=2;i<=n;i++){
			k^=1;
			int j=0;
			for(int len=1;len<=n;len++){
				if(vis[len])continue;
				j++;
				if(k==0&&len<last||k==1&&len>last){
					if(f[n-i+1][j][k]>=m){
						last=len;break;
					}
					else m-=f[n-i+1][j][k];
				}
			}
			vis[last]=1;
			printf(" %lld",last);
		}
		puts("");
	}
	return 0;
}

例题2：圆形数字

题目描述：

定义圆形数字如下：

把一个十进制数转换为一个无符号二进制数，若该二进制数中 0 的个数大于或等于 1 的个数，则它就是一个圆形数字。

现在给定两个正整数 a 和 b，请问在区间 [a,b] 内有多少个圆形数字。

分析

下面简称圆数
对于这道题，由于其与二进制有关，且要命的是这个二进制数不能含有前导零，且统计与0有关，这就逼迫我们不得不不记录前导零
那么对于这道题DP的状态就很明显了，设$f[i,j]$表示有$i$位的数里有$j$位是0（不含前导零）的数的数量
不难发现,这个数很容易抽象成：给定$i$个数，需要从中选出$j$个强制变成0，并且不能选择第一个数(为开头的1),很明显这就是一个组合数：$f[i,j]=C_{i-1}^j$，值得说的是，我们之所以以0来作为状态而不是1，是因为0相对于1更方便统计，因为组合数可以直接算，这里就不说了，当然也可以借$C_n^m=C_{n-1}^m+C_{n-1}^{m-1}$这个性质计算
那么我们下面讨论如何求$[1,a]$中圆数的数量
考虑将a也拆成二进制，假设有$tot$位（$1\sim tot$），那么对于二进制表示下位数不足$tot$的部分就非常容易统计了
这部分的贡献一共是
$$\sum _{i=1}^{tot-1}\sum _{j=\lceil \frac{i}{2}\rceil }^{i-1}f[i,j]$$
很快可以算出来，然后我们考虑第$tot$位该怎么算
我们设$a$被二进制分解为$a_{tot}{a}_{tot-1}\dots a_1$（从高到低）
下面我们按从高到低的顺序进行拼凑
详细地说，我们设当前已经拼到了第$i$位，第$tot\sim i+1$一共有$b$个0，当前累计的答案为$ans$，那么我们就可以分类讨论了

1. $a_i=1$，此时如果我们拼的数这一位取0，那么这个数后面无论再怎么取都一定不会超过$a$了，于是我们就可以把取0这一部分的答案累加上，写成公式是：
   $$ans=ans+\sum _{k=\lceil \frac{tot}{2}\rceil -b-1}^{i-1}f[i,k]$$
2. $a_i=0$,令$b=b+1$
   一路统计下来我们就可以得到答案
   $$\mathrm{Code}$$

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int num[55],cnt,tot,c[55][55],n,m,a,b;
#define f(i,j) c[i-1][j]
int solve(int a){
	if(a==0)return 0; 
	tot=0;
	while(a){
		num[++tot]=a&1;
		a>>=1;
	}
	int ans=0;
	for(int i=1;i<tot;i++){
		int k=(i+1)/2;
		for(int j=k;j<=i;j++){
			ans+=f(i,j);
		}
	}
	int b=0;
	for(int i=tot-1;i>0;--i){
		if(num[i]==1){
			for(int p=(tot+1)/2-b-1;p<=i;p++)ans+=f(i,p);//加上这一位填0的收益 
		}
		else b++;
	}
	if(b>=(tot+1)/2)ans++;
	return ans;
}
int main(){
	for(int i=0;i<=30;i++)c[i][0]=1;
	for(int i=1;i<=30;i++){
		for(int j=1;j<=i;j++){
			c[i][j]=c[i-1][j-1]+c[i-1][j];
		}
	}
	scanf("%d%d",&a,&b);
	printf("%d\n",-(solve(a-1)-solve(b)));
} 

例题3：计数问题

这个题直接来一个数学做法

具体看我做题时的手稿：

至少我认为这还是比较好懂的，我们只需要把问题转换为前缀和来做就可以了，顺带的，$1\sim 9$可以像我手稿上的直接做，但是0的时候注意前导零，具体看代码

int cnt(int n,int num) {
    int ans=0,i=1,qd0=0;//前导零
    while(i<=n){
        int l=n/i,r=n%i;
        ans+=(l+9-num)/10*i;
        if(l%10==num)ans+=r+1;
        if(!num)qd0+=i;
        i*=10;
    }
    if(!num)qd0-=1;
    return ans-qd0;
}
int main(){
    int a,b;
    while(~scanf("%d%d",&a,&b)&&a&&b) {
        if(a>b)a^=b,b^=a,a^=b;//装逼必备，把式子展开你就懂了
        for(int i=0;i<=9;++i) 
            printf("%d ",cnt(b,i)-cnt(a-1,i));
        puts("");
    }
    return 0;
}

对动态规划的学习就告一段落啦

$$\mathrm{完结撒花}$$