动态规划
引例：
斐波那契数列：
边界条件：f0=0；
f1=1；
能够直接被求出值的状态
不需要计算其他斐波那契数列的值直接可以得到结果；
转移方程：fn=fn-1+fn-2如何用已有状态求出未知状态
前几项：0,1,1,2,3,5,8,13……
状态：f1，f2，f3……fn；（要求的未知的量）
DAG<=>无后效性？？（暂时不用管什么东西）
通项公式：
法1：记忆化搜索（一般来说用不上qwq）
会多开一个记录是否算过的数组，故空间会比下面两种大一点
法2：顺着推：用自己去推别人
法3：倒着推：用别人更新自己
#include<iostream> #include<cstdio> using namspace std; int n,f[233]; /*斐波那契数列：倒着推 int main(){ cin>>n; f[0]=0; f[1]=1; for(int a=2;a<n;a++) { f[a]=f[a-1]+f[a-2]; } cout<<f[n]<<endl; }*/ /*斐波那契数列：顺着推 int main(){ cin>>n; f[0]=0; f[1]=1; for(int a=0;a<n;a++){ f[a+1]+=f[a]; f[a+2]+=f[a]; } cout<<f[n]<<endl; } */ /*搜索 O(f(n)) 与斐波那契数列第n项大小成正比 约为1.6^n int dfs(int n){ if(n==0) return 0; if(n==1) return 1; return dfs(n-1)+dfs(n-2); } int main(){ cin>>n; cout<<dfs(n)<<endl; return 0 } */ /*记忆化搜索 O(n) 在计算过程中，保证f0~fn每个数只被算一次 bool suan_le_mei[n]; int dfs(int n){ if(n==0) return 0; if(n==1) return 1; if(suan_le_mei[n]) return f[n];//判断是否算过 suan_le_mei[n]=true; f[n]=dfs(n-1)+dfs(n-2); return f[n]; } int main(){ cin>>n; cout<<dfs(n)<<endl; return 0 }*/
常见DP种类:
数位DP-50%
树形DP-50%
状压DP-50%
区间DP-50%
（有套路^）
其他DP-80%
（无规律^）
考不到的DP：插头DP，博弈论DP，呸概率比较小
常见优化:
单调性优化
矩阵乘法优化
其他优化
放弃学习优化
看的一懵一懵的
数位DP
什么叫做数位DP？
按照数字的位数划分转移阶段
转移方式：枚举下一位数字填什么
限制条件：数位的上下界要求
读入两个正整数l，r，问从l~r有多少个数？
显然ans=r-l+1；
但是，我们的钟神拒绝平常，他要与众不同，他要用数位DP做qwq
第一步：转化：[0,r]数的个数-[0,l-1]的数的个数=>转化成解决[0,x]有多少数=>有多少个v使得0<=v<=x;
x=>xn xn-1 xn-2……x0
v=>vn vn-1vn-2……v0（至多n位）给每位填上0~9的数，看有多少种方案满足v<=x
从最高位=>最低位
举个栗子：填vn-3时，前面的都填好了
那么v的前面的三位必须保证小于等于x的前三位，那么为了使v<=x，则需要:
分两种情况：1.x的前三位大于v的前三位=>vn-3可以填任何数
2．x的前三位等于v的前三位=>0~xn-3
f[i][j（0/1）] 代表这种情况的方案数
i：已经填好了第i位，j=>0/1
j=0=>xnxn-1……xi>vnvn-1……vi；
j=1=>xnxn-1……xi=vnvn-1……vi；
转移：枚举第i-1位填什么
填第i位，从i+1位转移过来.
边界：第n+1位（相等且没有数）f[n+1][1]=1；（都填0）
#include<iostream> using namespace std; int l,r,z[233]; int f[2333][2]; int solve(int x){ int n=0; while(x){//求出x的每一位（最后有n位)(从0下标开始) z[n]=x%10; x/=10; n++; } n--; memset(f,0,sizeof(f));//需要做两次DP，故要把数组清空 f[n+1][1]=1;//边界条件：第n+1位显然都填0，所以相等的方案数为1 //不相等的方案数为0 for(int a=n;a>=0;a--)//枚举要填的第a位 { for(int b=0;b<=1;b++)//考虑相等还是小于分两种讨论qwq if(b==0){//x>v for(int c=0;c<=9;c++) f[a][0]+=f[a+1][b]; } else { for(int c=0;c<=z[a];c++){ if(c==z[a])f[a][1]+=f[a+1][b]//c==z[a],代表填上这个数后v=x else f[a][0]+=f[a+1][b];//c!=z[a],代表填上这个数后v<x } } } return f[0][0]+f[0][1]; } int main(){ cin>>l>>r; cout<<solve(r)-solve(l-1)<<endl; return 0; }
problem2：
求[l,r]中的数的数位之和
#include<iostream> #include<cstring> using namespace std; int l,r,z[233]; int f[2333][2]; int g[2333][2];//ij表达与f相同 int solve(int x){ int n=0; while(x){//求出x的每一位（最后有n位)(从0下标开始) z[n]=x%10; x/=10; n++; } n--; memset(f,0,sizeof(f));//需要做两次DP，故要把数组清空 memset(g,0,sizeof(g)); f[n+1][1]=1;//边界条件：第n+1位显然都填0，所以相等的方案数为1，不相等的方案数为0 g[n+1][1]=0; for(int a=n;a>=0;a--)//枚举要填的第a位 { for(int b=0;b<=1;b++)//考虑相等还是小于分两种讨论qwq if(b==0){//x>v for(int c=0;c<=9;c++){ f[a][0]+=f[a+1][b]; g[a][0]+=g[a+1][b]+f[a+1][b]*c;//先加上前a+1位的和，然后对于第a位，可以填0~9任一，那么每填一个数c，每一种方案的和都+c，故要用方案数*c } } else { for(int c=0;c<=z[a];c++){ if(c==z[a]){ f[a][1]+=f[a+1][b]; g[a][1]+=g[a+1][b]+f[a+1][b]*c; }//c==z[a],代表填上这个数后v=x else { f[a][0]+=f[a+1][b];//c!=z[a],代表填上这个数后v<x g[a][0]+=g[a+1][b]+f[a+1][b]*c; } } } } //return f[0][0]+f[0][1]; return g[0][0]+g[0][1]; } int main(){ cin>>l>>r; cout<<solve(r)-solve(l-1)<<endl; return 0; }
problem3：
求在[l,r]中的满足相邻两个数字之差至少为2的数有多少个
多一维条件，多一个状态。
f[i][j][k]已经填好了第i位；j：0/1表示</=；k：第i位填了k
保证第i位和第i+1位的数字大小差至少2；
树形DP：
什么是树形DP：
按照树从根往下或者叶子网上划分阶段
转移方式：集合叶子或者父亲的信息
限制条件：不详
给你一个n个点的数，问有多少个点？？？闲圈啊qwq
f[i]以i为根的子树中共有多少个点
边界条件：叶节点的f为1；f[叶子]=1;
f[p]=f[p1]+f[p2]+1;
转移方程 f[i]=f[son1]+f[son2]+……+f[sonn]+1
eg:
给我一个n个点的数，求这棵树的直径是多少？
直径：在一棵树上找到两个点，使得这两点间的距离最远。
树路径长度，从根结点到某结点的边数。
考虑一棵子树内的直径qwq
路径长这样：
可以把直径看成从某一点向下走了两条路然后合起来
找两种向下走最长的两条路径
即从一点向下走最长可以走多少和次长可以走多少。
状态定义：f[i][0]i向下最长那条路长度是多少
f[i][1]i乡下的次长的那条路的长度
转移方程：(n个儿子)
f[p][0]=max(f[son1][0],f[son2][0]……,f[sonn][0])+1;
假设最大的是son2,那么显然我们不能再走son2了
f[p][1]=max(f[son1][0],f[son3][0],……f[sonn][0])+1;
ans=max（f[i][0]+f[i][1]）;(枚举所有的i找最大的一个)
区间DP：
满足：
合并相邻的
把所有的合并成一个东西
的为区间DP；
eg：合并石子
n堆石头，a1,a2……an，可以合并相邻的两堆石子，合并的代价：合并的这两堆的石头数之和。（合并n-1次qwq）现在把这n堆石头合并为1堆，使代价最小。
状态：f[l][r]代表把第l堆石子到第r堆石子合并为一堆石子的最小代价
要求的即为f[1][n]
边界条件：l=r时答案为0；即f[i][i]=0；
转移方程：f[l][r]=min(f[l][p]+f[p+1][r]+sum[l][r])
合并过程并没有改变石头的顺序，最后一定为把两堆合并为一堆，那么一定可以找到一条分界线p，左边为al~ap右边为ap+1,~ar
左边合并的最小代价即为f[l][p],右侧为f[p+1][r];
枚举一个点p把左右分别合并成一堆，然后再合并成一堆
复杂度：O（n3）（n的极限约为100~200左右）
石子合并：洛谷p1880
处理第1堆和第n堆相邻的情况
很自然的想法：
最后的答案可能不是f[1][n]
an和a1相邻，a1，a2不相邻的情况：f[2][n+1]
再加一个a2：
继续向后面加：（在原来序列基础上补上一个相同的序列）
取min
原理：
对于一个环形排序的n堆物品，要把他们合并为一堆，需要合并n-1次，那么有一条边始终没有用到，我们可以看是断开的，也就是说，我们可以不看它，把长度延长为原来的两倍即为枚举要断开的边是哪一条
下午
状态压缩DP
什么叫状压DP：
按照选取集合的状态划分转移阶段
转移方式：枚举下一个要选取的物品
限制条件：不详
N个点：（x1，y1）（x2，y2）……（xN，yN）
从一号点出发，保证每个点都至少走一次，使得走过的路径的长度之和最短
TSP问题（旅行商问题）非常经典的NP-hard问题（想解决掉这种问题，至少为2n，n在指数上）qwq
一个点有没有必要走两次？？？没有=>最优情况下每个点只需去一次
应该怎么走？？？直接拉一条线段过去<=>两点间线段最短
已走：1 2 5
未走：3 4 6
现在的位置在5号点，那么接下来的状态：
如何把集合表示到代码里面去：（如何用一个数代表一个集合）构造一个n位的二进制数，
<=>{1,4,5}
转成10进制=>25
每个元素只可能 在/不在 集合中两种情况，第i位在集合中为1，不在集合中为0
设计这样一个DP方法：
f[s][i]
s:n位的二进制数，已经走到过的点
：{1,2,4,6}说明已经走过1,2,4,6点，对应二进制=>101011
i：现在停留在i点
初始化：f[1][1]=0；
转移：
从i点到j点，j属于1~n；
并且要判断j∉s
f[s∪{j}][j]<=f[s][i]+dis[i][j];
#include<cstdio> #include<iostream> using namespace std; const int manx=20; int n; double f[1<<maxn][maxn];//f[2的n次方][n]； double dis(int i,int j){ return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])); } int main(){ cin>>n; for(int a=0;a<n;a++)//二进制最低位是第0位 cin>>x[a]>>y[a]; for(int a=0;a<(1<<n);a++) for(int b=0;b<n;b++) f[a][b]=1e+20; f[1][0]=0;//初始化 //转移：较小的s=>较大的s，从小到大枚举s for(int s=1;s<(1<<n);s++) for(int i=0;i<n;i++) if(((s>>i)&1)==1) for(int j=0;j<n;j++) if(((s>>j)&1)==0) f[s|(1<<j)][j]=min(f[s|(1<<j)][j],f[s][i]+dfs(i,j)); double ans=le+20; for(int a=1;a<n;a++) ans=min(ans,f[(1<<n)-1][a]); cout<<ans<<endl; }
状压DP：
时间复杂度：O(n2*2n) 空间复杂度：O（2n*n）能接受的数据范围：n<=20（大约是，有时候可以达到22）
一般机子1s可以跑107~109看机子不同吧qwq
一些数据范围推复杂度和算法：
n≤12=>暴搜
n≤20（22）=>状压
n≤32 =>放弃
n≤50 =>放弃
n≤100 =>n3
n≤1000 =>n2
n≤105=>数据结构，线段树
n≤106=>线性的
n>106=>考虑O(1)的算法
在这普通的一天，我穿着普通的鞋，很普通地来到这普通的酒店，打开普通的电脑，找点普通的感觉，学一点我最爱的普通DP
普通DP
题目多一个条件=>多一个维度
first：
边界条件：
第一行和第一列全部为1:f[i][1]=f[1][j]=1；
转移：f[i][j]=f[i-1][j]+f[i][j-1];
上次zt钟神也讲的一个东西：
n行m列：从左上走到右下的方案数：Cn+m-2n-1
数字三角形：
洛谷p1216
每次可以向下或右下走。
这条路径的权值：这条路上所有数的和
求最大值
状态f[i][j]表示在走到（i，j）这个点最大的权值是多少；
边界条件：f[1][1]=a[1][1]；
转移方程式：f[i][j]=max(f[i-1][j-1],f[i-1][j])+a[i][j];
数字三角形改：
从a[1][1]向下或向右下走，使得路径权值mod m后的值最大
n,m<=100；
感性理解：
为什么不给大一点？？？
1.给大了做不了 m可能也是一个维度
2.出题人懒得给大数据（wz啊）
边界：f[1][1][a[1][1]]=true;
状态：f[i][j][k]走到i行j列%m==k是可能or不可能
转移：f[i][j][k]=f[i-1][j-1][k-a[i][j]]orf[i-1][j][k-a[i][j]]
注意k-a[i][j]可能会为负，故要取模
ans最后一行中可能出现的k中最大的
codevs 上的一道题
下一个问题：
最长上升子序列
不细讲了大家都做过qwq：
给定一个序列a1,a2,a3……an
找出一个序列b1,b2……bk使得：ab1<ab2<……abk
f[i]表示找一个以i号点结尾的最长上升子序列长度
转移：找一个j使得1<=j<i,aj<ai枚举f[i]=max f[j]+1;
复杂度O（n2）
加强一下：数据范围n<=105
线段树qwq没学好啊
假设v=max（a1,a2,a3……,an）
建一棵大小为n的线段树（按值来做左右划分）
线段树：区间询问最大值&单点修改？？？
有点特殊的DP：背包问题
背包九讲
最基本背包问题：有n个物品，第i个物品价值为w[i]，体积为v[i]，现在有一个背包大小为m，在不超过背包容积情况下，价值最大。
01背包
状态定义：f[i][j]把前面i个物品是否放进背包已经考虑完了，背包中已经使用了j的体积的最大价值。
转移：如果不放进背包=>f[i][j]=>f[i+1][j] 0转移
如果放进背包=>f[i][j] +w[i+1]=>f[i+1][j+v[i+1]] 1转移
f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
无穷背包（完全背包）
有n个物品，第i个物品价值为w[i]，体积为v[i]，每种物品都有无数个，问同上；
未优化：
转移方程：f[i][j]=max(f[i-1][j],f[i][j-v[i]]+w[i])O（nm）
存在转移链：
f[i][j]<=f[i][j-v[i]]<=f[i][j-2v[i]]；
有限背包：
做法：枚举每个物品要用多少个（同无穷背包未优化的操作）
eg：求在[l,r]中满足各位数字之积为k的数有多少个
l，r<=1018
再加一维:f[i][j][k]填到i位，j=0 => “<”,j=1 => “=”,乘积为k；
k:max:918会炸，因为0~9中质因数只有2,3,5,7，故k=2a*3b*5c*7d
拆维度qwq拆的我一脸懵逼：
有的时候维度多并不代表会炸掉，有时反而或许可以降低复杂度qwq。
很神奇，你居然看到了最后，tql
那么接下来就是钟神语录了（算是看到最后的小彩蛋吧qwq）
"虽然我不知道你说的是什么，但肯定是错的"
“这个题我是从vijos看到的，不知道这个oj还活着没有”
“当你发现你这样做做不出来时，加一个维度，还做不出来，再加一个维度QWQ”