线性dp，区间dp

最长上升子序列
设置f[i],表示以第i个数结尾的上升子序列的最大长度
第i个数可以接到在它之前比他小的所有数后面
所以f[i],就是前面计算出来的所有比它小的数的f[j]+1的最大值
所以
f[i]=max(f[i],f[j]+1);
复杂度O(n^2)

#include<iostream>
using namespace std;
const int N=1000;
int a[N],f[N];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) f[i]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i-1;j++)
        {
            if(a[j]<a[i]) f[i]=max(f[i],f[j]+1);
        }
    }
    int res=0;
    for(int i=1;i<=n;i++) res=max(res,f[i]);
    cout<<res<<endl;
    return 0;
}

找出最长上升子序列
用一个数组来记录当前状态更新是由哪里更新过来的

#include<iostream>
#include<vector>
using namespace std;
const int N=1000;
int a[N],f[N],fr[N];
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) f[i]=1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i-1;j++)
        {
            if(a[j]<a[i]) 
            {
                if(f[j]+1>f[i])
                {
                    f[i]=f[j]+1;
                    fr[i]=j;
                }
            }
        }
    }
    int res=0;
    int indx;
    for(int i=1;i<=n;i++) 
    {
        if(f[i]>res)
        {
            res=f[i];
            indx=i;
        }
    }
    vector<int> t;
    t.push_back(a[indx]);
    while(fr[indx])
    {
        t.push_back(a[fr[indx]]);
        indx=fr[indx];
    }
    cout<<res<<endl;
    for(int i=t.size()-1;i>=0;i--) cout<<t[i]<<" ";
    return 0;
}

优化
上面的代码中是有冗余的
冗余在于，比他小的并不是每一个都要比，只要找到比它小的中长度最大的
然后找的话，只关注他能不能接上，也就是这个最长的最后一个值是不是小于他
所以要记录的就是最长的那个长度和最后一个的值
所以用h[i]来记录，长度为i的最后那个值
并且长度一样的最长序列，最后一个值比较大的，没必要存在

因为h数组是严格单调的
所以就可以用二分来找这个数应该加到那个位置
找的数，就是比他小并且最接近他的，因为如果比他大，就接不上，比他小的都可以接，当然接到最长的是最好的

#include<iostream>
#include<cstring>
using namespace std;
const int N=100010;
int h[N],a[N];
int main()
{
    memset(h,0x3f,sizeof h);
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    int len=0;
    for(int i=1;i<=n;i++)
    {
        int l=0,r=len;
        while(l<r)
        {
            int m=l+r+1>>1;
            if(h[m]<a[i]) l=m;
            else r=m-1;
        }
        len=max(len,r+1);
        h[r+1]=min(h[r+1],a[i]);
    }
    cout<<len<<endl;
    return 0;
}

最长公共子序列
设置f[i][j]表示a串前i个和b串前j个的最大公共子串长度
那么当a[i]==a[j]的时候，最大公共子串长度就是f[i-1,j-1]+1
当不相等的时候，就代表要么是有a[i]没有b[j]的，要么反之，要么就是都没有的。也就是f[i-1,j]和f[i,j-1]

#include<iostream>
using namespace std;
const int N=1010;
char a[N],b[N];
int f[N][N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int j=1;j<=m;j++) cin>>b[j];
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++)
    if(a[i]==b[j]) f[i][j]=f[i-1][j-1]+1;
    else f[i][j]=max(f[i-1][j],f[i][j-1]);
    cout<<f[n][m]<<endl;
    return 0;
}

最短编辑距离
设置转态为f[i,j]表示a前i个边乘b前j个
所以可以分成3个
1，通过删除来的，f[i-1,j]+1
2，通过增加来的 ,f[i,j-1]+1
3,通过修改来的
2种情况 if a[i]==b[j] 就是f[i-1,j-1]
else 就是f[i-1,j-1]+1

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];
char a[N],b[N];
int n,m;
int main()
{
    cin>>n>>a+1;
    cin>>m>>b+1;
    for(int i=0;i<=n;i++) f[i][0]=i;
    for(int i=0;i<=m;i++) f[0][i]=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);
        }
    cout<<f[n][m]<<endl;
    return 0;
}

动态规划每个状态都是有意义的，所以一定要注意一开始的初始化边界

区间dp
就是在定义状态的时候把状态定义成区间

acwing.282 石子合并
因为每次合并只能合并相邻的2个,也就可以想成把一个区间里的东西进行合并
设置状态f[i,j]表示在i到j这个区间里，合并完后的最小值
状态计算
f[i,j]要计算出来，要做的最后一步是合并2个区间,也就是说可以把i到j划分成2个区间然后枚举不同划分情况，找到最小值+这次合并需要的价值
这次合并的价值其实就是i到j这个区间内数的和
用k枚举分界点，s数组保存前缀和
所以f[i,j]=min(f[i,j],f[i,k]+f[k+1,j]+s[j]-s[i-1])
由于状态转移方程中每次需要比当前小的区间，所以枚举的时候要从小的区间开始枚举.

#include<iostream>
using namespace std;
const int N=310;
int f[N][N];
int s[N];
int n;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) 
    {
        cin>>s[i];
        s[i]+=s[i-1];
    }
    for(int len=2;len<=n;len++)//枚举区间长度，len=1不用枚举，因为不用体力为0
    for(int i=1;i+len-1<=n;i++)//枚举区间的起点
    {
        int l=i,r=i+len-1;//区间
        f[l][r]=0x3f3f3f3f;//因为是找最小值，所以一开始要初始化成最大值
        for(int k=l;k<=r-1;k++)//枚举分界点，只能到r-1因为要有2个小区间
        f[l][r]=min(f[l][r],f[l][k]+f[k+1][r]+s[r]-s[l-1]);
    }
    cout<<f[1][n]<<endl;//最后答案就在1到n这个区间里
    return 0;
}