动态规划板子库

这里的python全是python3的
详情请见acwing，acwing赛高
力求快、准、狠、短

---

#写在前面

C++一秒能算10^7~8次；
动态规划快，是因为它每个状态能表示一堆方案，并取某个最值；
Dfs则要遍历每一种方案，所以会比较慢

动态规划的思考，采用闫氏思考法，分为状态表示和状态计算

状态表示主要分为集合的定义和集合属性的确定，状态的计算主要对应集合的划分，

集合的划分的一个很重要的依据就是按照最后一步来划分。

闫氏思考法实际上是用集合的角度去思考某种最优化问题
在有限集合中求最值、或者求个数
无限集可以通过某种手段转化为有限集

#背包模型

https://blog.csdn.net/lafea/article/details/108546667

#状态机模型

https://blog.csdn.net/lafea/article/details/108692292

#线性Dp

##数字三角形模型

https://blog.csdn.net/lafea/article/details/108312348

##最长上升子序列模型

https://blog.csdn.net/lafea/article/details/108368616

##最短编辑距离

https://www.acwing.com/problem/content/904/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1010;

int n,m;
char a[N],b[N];
int f[N][N];

int main(){
    scanf("%d%s", &n, a+1);
    scanf("%d%s", &m, b+1);
    //边界条件初始化
    for(int i=0;i<=m;i++)f[0][i]=i;
    for(int i=0;i<=n;i++)f[i][0]=i;
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
            if(a[i]==b[j])f[i][j]=min(f[i][j], f[i-1][j-1]);
            else f[i][j]=min(f[i][j], f[i-1][j-1]+1);
        }//这也太尼玛抽象了
        
    printf("%d",f[n][m]);
    return 0;
}

##编辑距离

https://www.acwing.com/problem/content/901/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;

const int N=15, M=1010;

int n,m;
int f[N][N];
char str[M][N];

#include<string.h>//算字符串长度
int edit_distance(char a[], char b[]){
    int la=strlen(a+1), lb=strlen(b+1);
    for(int i=0;i<=lb;i++)f[0][i]=i;
    for(int i=0;i<=la;i++)f[i][0]=i;
    
    for(int i=1;i<=la;i++)
        for(int j=1;j<=lb;j++){
            f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
            f[i][j]=min(f[i][j],f[i-1][j-1]+(a[i]!=b[j]));
        }
    return f[la][lb];
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++)scanf("%s",str[i]+1);
    
    while(m--){
        char s[N];
        int limit;
        scanf("%s%d", s+1, &limit);
        
        int res=0;
        for(int i=0;i<n;i++)
            if(edit_distance(str[i], s)<=limit)
                res++;
        
        printf("%d\n", res);
    }
    
    return 0;
}

#区间Dp模型

https://blog.csdn.net/lafea/article/details/108808218

#计数类Dp

##整数划分

https://www.acwing.com/problem/content/902/

----c++版

#include<iostream>
#include<algorithm>
//求方案数时不考虑数和数的顺序
using namespace std;
//可以看成完全背包问题 1-n 的数任取，正好组成该整数 
//集合：从1-i中选，体积恰好是j的选法的集合。
//属性：数量。计算：将所有选法数量相加
//可以优化成一维
const int N=1010, mod=1e9+7;
int n;
int f[N];
int main(){ 
    cin>>n;
    f[0]=1;//一个都不选，一种方案
    for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++)//完全背包，从小到大循环
            f[j]=(f[j]+f[j-i])%mod;

    cout<<f[n]<<endl;
    return 0;
}

#include<iostream>
#include<algorithm>
//求方案数时不考虑数和数的顺序
using namespace std;

//我们还可以这样考虑：
//集合：所有总和是i，并且恰好表示成j个数的和的方案
//属性：数量
//计算：集合划分成方案数字最小值是1/大于一
//最小值大于一的可以把每个数都减去1
//f[i][j]=f[i-1][j-1]+f[i-j][j]
//ans=f[n][1]+f[n][2]+...+f[n][n]
const int N=1010,mod=1e9+7; 
int n;
int f[N][N];
int main(){ 
    cin>>n;
    f[0][0]=1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            f[i][j]=(f[i-1][j-1]+f[i-j][j])%mod;
    int res=0;
    for(int i=1;i<=n;i++)res=(res+f[n][i])%mod;
    cout<<res;
    return 0;
}

#数位统计Dp模型

https://blog.csdn.net/lafea/article/details/108903010

#状态压缩Dp模型

https://blog.csdn.net/lafea/article/details/108734493

#树形Dp模型

https://blog.csdn.net/lafea/article/details/108847432

#单调队列优化的dp问题模型

https://blog.csdn.net/lafea/article/details/108927882

#斜率（凸包）优化的dp问题模型

https://blog.csdn.net/lafea/article/details/108978095

#记忆化搜索

代码复杂度低

##滑雪

https://www.acwing.com/problem/content/903/

----c++版

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
//状态：f[i,j]所有从i，j开始滑的路径
//属性：max
//计算：集合划分成向上下左右滑，每个方向取最大值
//递归的要求是无环，即为拓扑图
const int N=310;
int n,m;
int h[N][N];
int f[N][N];

int dx[4]={-1,0,1,0},dy[4]={0,1,0,-1};

int dp(int x,int y){
    int &v=f[x][y];
    if(v!=-1)return v;
    v=1;
    for(int i=0;i<4;i++){
        int a=x+dx[i],b=y+dy[i];
        if(a>=1&&a<=n&&b>=1&&b<=m&&h[a][b]<h[x][y]){
            v=max(v, dp(a,b)+1);
        }
    }
    return v;
}

int main(){
    scanf("%d%d",&n,&m); 
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            scanf("%d",&h[i][j]);
    memset(f, -1, sizeof f);//每个状态都没有被算过
    
    int res=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            res=max(res, dp(i,j));//不能直接调用f[i,j],还没有求出来
    
    printf("%d",res);
    return 0;
}