【五一qbxt】day3 动态规划

动态规划

引例：

斐波那契数列：
边界条件：f₀=0；

                  f₁=1；

能够直接被求出值的状态

不需要计算其他斐波那契数列的值直接可以得到结果；

转移方程：f_n=f_n-1+f_n-2如何用已有状态求出未知状态

前几项：0,1,1,2,3,5,8,13……

状态：f1，f2，f3……fn；（要求的未知的量）

DAG<=>无后效性？？（暂时不用管什么东西）

通项公式：

实现DP

法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=>x_n x_n-1 x_n-2……x₀

v=>v_n v_n-1v_n-2……v₀（至多n位）给每位填上0~9的数，看有多少种方案满足v<=x

从最高位=>最低位

举个栗子：填v_n-3时，前面的都填好了

那么v的前面的三位必须保证小于等于x的前三位，那么为了使v<=x，则需要:

分两种情况：1.x的前三位大于v的前三位=>v_n-3可以填任何数

                      2．x的前三位等于v的前三位=>0~x_n-3

  

f[i][j（0/1）] 代表这种情况的方案数

i：已经填好了第i位，j=>0/1

j=0=>x_nx_n-1……x_i>v_nv_n-1……v_i；

j=1=>x_nx_n-1……x_i=v_nv_n-1……v_i；

转移：枚举第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；

windy数qwq

 

树形DP：

什么是树形DP：

按照树从根往下或者叶子网上划分阶段

转移方式：集合叶子或者父亲的信息

限制条件：不详

给你一个n个点的数，问有多少个点？？？闲圈啊qwq

 

f[i]以i为根的子树中共有多少个点

边界条件：叶节点的f为1；f[叶子]=1;

f[p]=f[p1]+f[p2]+1;

 

转移方程 f[i]=f[son₁]+f[son₂]+……+f[son_n]+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（n³）（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个点：（x₁，y₁）（x₂，y₂）……（x_N，y_N）

从一号点出发，保证每个点都至少走一次，使得走过的路径的长度之和最短

TSP问题（旅行商问题）非常经典的NP-hard问题（想解决掉这种问题，至少为2ⁿ，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];

p1171

#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(n²*2ⁿ) 空间复杂度：O（2ⁿ*n）能接受的数据范围：n<=20（大约是，有时候可以达到22）

一般机子1s可以跑10⁷~10⁹看机子不同吧qwq

 一些数据范围推复杂度和算法：

n≤12=>暴搜

n≤20（22）=>状压

n≤32  =>放弃

n≤50  =>放弃

n≤100 =>n³

n≤1000 =>n^₂

n≤10⁵=>数据结构，线段树

n≤10⁶=>线性的

n>10⁶=>考虑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列：从左上走到右下的方案数：C_n+m-2^n-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使得：a_b1<a_b2<……a_bk

f[i]表示找一个以i号点结尾的最长上升子序列长度

转移：找一个j使得1<=j<i,aj<ai枚举f[i]=max f[j]+1;

复杂度O（n²）

加强一下：数据范围n<=10⁵

线段树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<=10¹⁸

再加一维:f[i][j][k]填到i位，j=0  => “<”,j=1  => “=”,乘积为k；

k:max:9¹⁸会炸，因为0~9中质因数只有2,3,5,7，故k=2^a*3^b*5^c*7^d

拆维度qwq拆的我一脸懵逼：

有的时候维度多并不代表会炸掉，有时反而或许可以降低复杂度qwq。

 很神奇，你居然看到了最后，tql

那么接下来就是钟神语录了（算是看到最后的小彩蛋吧qwq）

"虽然我不知道你说的是什么，但肯定是错的"

“这个题我是从vijos看到的，不知道这个oj还活着没有”

“当你发现你这样做做不出来时，加一个维度，还做不出来，再加一个维度QWQ”