动态规划
三种常见实现方法
对于一个斐波那契数列，我们想要求第n项的值，就需要一项一项的递归来求
来看代码
f[o] = 0;
f[1] = 1;
for (int i = 2; i <= n; ++i)
f[i] = f[i-1] + f[i-2];
cout << f[n] << endl;
这种的属于用其他的结果来算自己的结，如果我们换一种写法，就成了用自己的值更新别人的值
f[o] = 0;
f[1] = 1;
for (int i = 0;i <= n; ++i)
{
f[i + 1] += f[i];
f[i + 2] += f[i];
}
这两种方式都是存在的，但是存在某些题会有卡掉不同写法的毒瘤操作，所以两种都要掌握
最后一种写法就是
记忆化搜索
int dfs (int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
return dfs(n - 1) + dfs(n - 2);
}
时间复杂度就是 O(F[n])的，因为我们只能是用1，0来慢慢加上去的
有意思的是斐波那契的第n项和2^n差不多是一个级别的，死慢，为什么？？
你考虑f[n-1]被算了两次，这就造成了时间上的极大浪费，所以我们考虑能不能对已经求出来的数值进行记录， 这就是记忆化搜索
g[i]代表这个数有没有被算出来
int dfs (int n) {
if (n == 0)
return 0;
if (n == 1)
return 1;
if (g[n])
return f[n];
f[n] = dfs(n - 2) + dfs(n - 1);
g[n] = true;
return f[n];
}
如果已经被算出来过，就直接返回就行，所以就不用二次计算
终于进入动态规划啦
状态是说你要算什么，转移方程是说你要怎么算，对于无后效性的理解，就是动态规划的所有状态之间组成了一个DAG
拿斐波那契举例
1.状态就是f[n]
2.转移方程就是f[n] = f[n-1] + f[n-2]
当然这是一个无后效性的东西
当我们碰到一些转移顺序比较变态的题呢？考虑到状态之间都是DAG，我们就可以对状态跑一边拓扑排序，然后就可以for一遍就行了
一些特殊类型的DP
主要就是以下几种
背包问题
最easy的问题
luogu 1616 疯狂的采药
给定n种物品和一个背包。
物品i的体积是vi，其价值为wi，背包的容量为m。
应该如何选择装入背包中的物品，使得装入背包中物品的总价值最大？
怎么设计状态呢？考虑要一个物品一个物品的放，所以有一个变化量就是我现在放好了前i个物品了，第二个维度就是我现在放进去的物品体积之和是多少
所以这个题的状态就应该是f[i][j] 表示已经试过了放前i个物品（不保证都被放进去），消耗的体积和是j
转移方程就是考虑下一个物品怎么放，显然只有放或者不放，那么状态转移方程就是
从别人更新自己
f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i] ] + w[i]);
代码如下
int n, m, w[233], v[233];
int f[233][12345678];
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; ++i)
cin >> w[i] >> v[i];
for (int i = 1; i <= n; i++)
for (int j = V; j >= w[i]; j--)
f[j] = max(f[j], f[j - w[i]] + v[i]);
}
物品可以放无限次的背包（无限背包问题）
枚举一下一个物品放几个就行了
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= n; ++j)
for (int k = 0; k * v[i] <= j; k++)
f[i][j] = max(f[i][j], f[i][j - k * v[i]] + k * w[i]);
但是你用的是三重循环， 那肯定会t的飞起
我们考虑一个问题，同一个物品取多个，其实也就是重复转移了多少次对吧，所以我们改一下代码
for (int i = 1; i <= n; i++)
for (int j = w[i]; j <= V; j++)
f[j] = max(f[j], f[j - w[i]] + v[i]);
行了，完事
有限背包
对于有限次的个数，我们可以把它拆分成几个集合，利用二进制的方式来拆分，比如拆30
我就可以拆成 1, 2, 4, 8, 15。值得注意的是我们最后那个数是不一定符合2的整数次幂的，实际上就是最后的那个差而已
上代码
int n, m, w[233], v[233], cnt = 0;
int f[233][12345678];
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; ++i)
{
cin >> w[i] >> v[i] >> z;
while (x <= z)
{
v[++cnt] = v[i] * x;
w[cnt] = w[i] * x;
z -= x;
x *= 2;
}
if (z > 0)
{
v[++cnt] = v[i] * z;
w[cnt] = w[i] * z;
}
}
for (int i = 1; i <= n; i++)
for (int j = V; j >= w[i]; j--)
f[j] = max(f[j], f[j - w[i]] + v[i]);
}
背包就这么讲完了
基础DP
例题一 P1216 [IOI1994][USACO1.5]数字三角形 Number Triangles
题面我就不贴了，可以想到的肯定是dp了，不然他也不会在这啊hhh
考虑到对于一个点，是他从左上角还是右上角过来，所以我们就能得到转移方程
f[i][j] = max(f[i - 1][j], f[i - 1][j - 1]);
行了写完了
改造题目（EX NumberTriangles）
我们要使得找出来的权值和%m之后的值是最大的。
起初我的想法是用一个结构体来存实际权值和取模后的权值，但是是不行的，因为不再满足最优子结构原则了。（就是说实际权值和取模权值之间的大小没有必然联系，所以我们无法用状态转移方程来求最大最小）
我们考虑加一个维度，开一个bool数组f
f [i] [j] [k]
代表走到第i行第j列是路径权值和 % m = k 可不可能，那我们怎么转移呢
还是考虑一个点只有可能从它的左上方和右上方求值过来，那么我们就能得出状态转移方程了
f[i][j][k] = f[i - 1][j - 1][(k - a[i][j]) % m] || f[i - 1][j][(k - a[i][j]) % m]
边界情况的话，就是
f[1][1][a[1][1] % m] = true（按照状态的定义来理解就行，很好理解）
然后我们就遍历一遍最终结果就可以了
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= m; ++j)
{
if (f[n][i][j])
ans = max(ans, j);
}
}
我寻思着代不代码也无所谓了呗，但是反正zhx写了那我就无耻白嫖一下hhh
#include <bits/stdc++.h>
using namespace std;
const int Mod = 100;
const int maxn = 25 + 5;
int maps[maxn][maxn];
bool dp[maxn][maxn][100];
int main()
{
int n;
while (~scanf("%d", &n))
{
memset(maps, 0, sizeof(maps));
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
scanf("%d", &maps[i][j]);
dp[0][0][0] = dp[0][1][0] = true; //这个初始化很重要
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
{
for (int k = 0; k <= 99; k++)
{
int now;
if (dp[i - 1][j][k]) //当上一个这个数值存在时就可以加上当前状态的值
{
now = (maps[i][j] + k) % Mod;
dp[i][j][now] = true;
}
if (dp[i - 1][j - 1][k])
{
now = (maps[i][j] + k) % Mod;
dp[i][j][now] = true;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
for (int k = 0; k <= 99; k++)
{
if (dp[n][i][k])
{
ans = max(ans, k);
}
}
printf("%d
", ans);
}
}
一些话
钟神的dp极其牛逼，按照他本人的说法，对于一个dp题目，当前维度解决不了的时候，那就再加一个维度，总能跑出来的
最长上升子序列
dp[i]表示以i为结尾的最长上升子序列
转移的话就是枚举i前面的aj小于Ai的数
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j)
f[i] = max(f[i], f[j] + i);
不是很难啊，时间复杂度是N^2
但是我们把数据加强到n<=1e5了，那么怎么办呢
我们肯定不能再跑一次O(n^2)了啊，这里就考虑用线段树,就是运用一次昨天学习的线段树求区间最值的方法，把时间复杂度直接降到logn，这样一来，总的时间复杂度就是nlogn
v=max(a1,a2,a3,.....an)，每次计算f[i]
我们建一颗长度为n的线段树，然后直接进行划分，就是说两端区间的最长上升子序列就肯定是他的两个儿子的和，这样算起来就快不少了
区间DP
区间dp的特征就是给你一堆东西，你每次只能合并两个相邻的东西，一般状态就是
f [l] [r]
代表第l堆石子到第r堆石子的最小代价是多少
合并石子luogu1880
有N堆石子，现要将石子有序的合并成一堆，规定如下：每次只能移动相邻的2堆石子合并，合并花费为新合成的一堆石子的数量。求将这N堆石子合并成一堆的总花费最小（或最大）。
F[l][r]
表示把第l堆石子到第r堆石子合并为一对石子的代价
我们会发现做任何DP题的时候的都是走老三步（找状态，找边界条件，找状态转移方程）
这个题的边界条件就是L=R的时候，所以F[l][r]=0（l=r）
那么我们再来看状态转移方程，我们最后一次合并一定是把两堆石头合并成一堆石头，是把左边某一堆和右边某一堆，由于题目的限制，我们可以发现不管怎样合并，石头的顺序是不变的。
所以我们一定是可以找到一条分界线，使得左边是A1Ap的结果，右边是Ap+1Ar，那么我们只需要枚举一下p的位置就可以了。所以状态转移方程就是(所有的)
min(f[l][p] + F[p+1][r] + sum[l][r]);
看代码
int z[manx],f[maxn][maxn];
int main()
{
cin>>n;
for(int a=1;a<=n;a++)
cin>>z[a];//表示石子数
memset(f,0x3f,sizeof(f));//初始化为无穷大
for(int a=1;a<=n;a++)
f[a][a]=0;
//枚举左端点，右端点，断点
for(int l=1;i<=n;l++)//枚举左端点
{
for(int r=l+1;r<=n;i++)//枚举右端点
{
for(int p=l;p<r;p++)
{
f[l][r]=min(f[l][r],f[l][p]+f[p+1][r]+sum[l][p]);
//左边合并的代价+右边合并的代价+这段区间的石子之和
}
}
}
cout<<f[1][n]<<endl;
return 0；
}
先把所有的数组赋值，然后改一下边界条件
我们枚举一个左端点，枚举一个右端点，再枚举一个断点
很不幸，这种枚举方式是错的
贴图片
我明明认真听了好久啊喂
因为在任何时候，他都不满足DP的阶段性
你看啊，你在算f[1][n]时要用到f[2][n]，但它还没有被算过（什么鬼东西）
所以我们就得枚举区间长度，然后修改一下代码就可以了
一个不知道干啥的题（惆怅
给你n个矩阵，自定义顺序，使得运算次数最少
和上一个题比较像，大概意思就是把一堆矩阵合并成一个的最小代价
转移方程就是
s[j][i] = max(s[j][i], s[j][k] + s[k+1][i] + e[j] * e[k+1] * e[i+1]);
状压DP
在平面上有n个点，要求从1号点出发把每一个点都走一遍，求最短距离，这个和最小生成树没啥关系，就是个非常简单的二维平面图，你可以随便走（大雾
首先，我们没必要走两次同一个点，然后01表示一个点走没走过，我们就可以很容易的用一个n位二进制数来存当前状态下的最短距离，做到了状压
转移的话，枚举一个j
行了黈力就行
种草
john要在一片牧场上种草，每块草坪之间没有相邻的边
状态dp[i][j]表示前i行的草都种完了，s表示第i行的草种成了什么样
k国王
f[i][j][k]表示前i行的国王都种完了，s表示第i行的
数位dp
读入两个正整数L,R，问从L到R有多少个数，答案就是L-R+1，这肯定是没有什么挑战性啊是吧，为了挑战自己，我们用一下数位DP（大雾）
有一个叫做前缀和转换的东西