D5（太长了md没写完）

动态规划

三种常见实现方法

对于一个斐波那契数列，我们想要求第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）

那么我们再来看状态转移方程，我们最后一次合并一定是把两堆石头合并成一堆石头，是把左边某一堆和右边某一堆，由于题目的限制，我们可以发现不管怎样合并，石头的顺序是不变的。

所以我们一定是可以找到一条分界线，使得左边是A1_{Ap的结果，右边是Ap+1}Ar，那么我们只需要枚举一下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（大雾）

有一个叫做前缀和转换的东西