动态规划==＞递归==＞状态转移方程(最长递增子序列,最大子串和,最长公共子串,最长公共子序列)

一些简单的动态规划的题，比如：

最长递增子序列

最大子串和

最长公共子串

最长公共子序列

从中可以发现动态规划的核心实质：将一个复杂的问题拆解为更小的子问题，存储子问题的答案避免重复计算，从而得到更优解。

1>>最长递增子序列：

首先，利用递归的思想。

#include<iostream>
using namespace std;
int a[101000];
//dfs(k)表示a[k]结尾的最长递增子序列的长度值
int dfs(int k){
    if(k==1){
        return 1;
    }
    int t=0;
    for(int i=1;i<=k;i++){
        if(a[i]<a[k]){
            t=max(t,dfs(i));//要找比a[k]小的数的最长递增子序列的长度值
        }
    }
    return t+1;//+1是因为加上a[k]本身
}
int main(){
    int n;
    cin>>n;

    for(int i=1;i<=n;i++){
        cin>>a[i];
    }

    int ans=0;
    for(int i=1;i<=n;i++){
        ans=max(ans,dfs(i));
    }

    cout<<ans<<endl;
    return 0;
}

其次，运用记忆化搜索的方式来记录之前的值

#include<iostream>
using namespace std;
int a[101000],dp[101000];
//dp[k]=dfs(k),也就是第k阶段的状态值
//dfs(k)表示a[k]结尾的最长递增子序列的长度值
int dfs(int k){
    if(k==1){
        return 1;
    }
    if(dp[k]!=0){//记忆化搜索
        return dp[k];
    }
    int t=0;
    for(int i=1;i<=k;i++){
        if(a[i]<a[k]){
            t=max(t,dfs(i));//要找比a[k]小的数的最长递增子序列的长度值
        }
    }
    return dp[k]=t+1;//+1是因为加上a[k]本身
}
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
    cin>>a[i];
    }

    int ans=0;
    for(int i=1;i<=n;i++){
        ans=max(ans,dfs(i));
    }

    cout<<ans<<endl;
    return 0;
}

最后呢，可以由递归公式推出动态转移方程

递归公式：

  int t=0;
    for(int i=1;i<=k;i++){
        if(a[i]<a[k]){
            t=max(t,dfs(i));
        }
    }
    return dp[k]=t+1;
}

 状态转移方程：

int t=0;
for(int i=1;i<=k;i++){
    if(a[i]<a[k]){
        t=max(t,dp[i]);
    }
}
dp[k]=t+1

完整的代码：

#include<iostream>
using namespace std;
int a[101000],dp[101000];
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
    cin>>a[i];
    }

    int ans=0;
    for(int k=1;k<=n;k++){
        int t=0;
      for(int i=1;i<=k;i++){
        if(a[i]<a[k]){
            t=max(t,dp[i]);
        }
    }
        dp[k]=t+1;
        ans=max(ans,dp[k]);
    }

    cout<<ans<<endl;
    return 0;
}

2>>最大子串和：

首先，运用递归的思想 

#include<iostream>
using namespace std;
int a[101000];
//dfs表示以a[k]结尾的子串的最大值
int dfs(int k){
    if(k==1)  return a[k];
    if(dfs(k-1)>0) return dfs(k-1)+a[k];
    else  return a[k];
}
int main(){
    int n;
    cin>>n;

    for(int i=1;i<=n;i++){
        cin>>a[i];
    }

    int ans=0;
    for(int i=1;i<=n;i++){
        ans=max(ans,dfs(i));
    }

    cout<<ans<<endl;
    return 0;
}

其次，增加记忆化搜索 ，因为要求的是子串和，所以不应该用赋值的方式来记录dp[k]是否被计算过，用bool类型更合适

#include<iostream>
using namespace std;
int a[101000],dp[101000];
bool v[101000];
//dfs表示以a[k]结尾的字串的最大值
int dfs(int k){
    if(k==1)  return dp[k]=a[k];
    if(dp[k])    return dp[k];
    v[k]=true;//证明dp[k]没有被计算过，接下来要算它了
    if(dfs(k-1)>0) return dp[k]=dfs(k-1)+a[k];
    else  return dp[k]=a[k];
}
int main(){
    int n;
    cin>>n;

    for(int i=1;i<=n;i++){
        cin>>a[i];
    }

    int ans=0;
    for(int i=1;i<=n;i++){
        ans=max(ans,dfs(i));
    }

    cout<<ans<<endl;
    return 0;
}

最后，推导状态转移方程 

递归公式：

if(dfs(k-1)>0) return dp[k]=dfs(k-1)+a[k];
    else  return dp[k]=a[k];

状态转移方程：

 if(dp[k-1]>0) dp[k]=dp[k-1]+a[k];
    else  dp[k]=a[k];

运用动态转移方程后完整的代码：

#include<iostream>
using namespace std;
int a[101000],dp[101000];
int main(){
    int n;
    cin>>n;

    for(int i=1;i<=n;i++){
        cin>>a[i];
    }

    int ans=0;
    for(int k=1;k<=n;k++){
     if(dp[k-1]>0) dp[k]=dp[k-1]+a[k];
      else  dp[k]=a[k];
      ans=max(ans,dp[k]);
    }

    cout<<ans<<endl;
    return 0;
}

3>>最长公共子串

首先，运用递归的思想

#include<iostream>
#include<cstring>
using namespace std;
char a[101],b[101];
int la,lb,ans;
//dfs(ia,ib)表示以a[ia]和b[ib]结尾的公共子串的长度
int dfs(int ia,int ib){
    if(ia<0||ib<0) return 0;
    if(a[ia]==b[ib]) return dfs(ia-1,ib-1)+1;
    else return 0;

}
int main(){
    cin>>a>>b;
    la=strlen(a);
    lb=strlen(b);

    for(int i=0;i<la;i++){
        for(int j=0;j<lb;j++){
            ans=max(ans,dfs(i,j));
        }
    }

    cout<<ans<<endl;
    return 0;
}

其次，运用记忆化搜索

#include<iostream>
#include<cstring>
using namespace std;
char a[101],b[101];
int la,lb,ans;
int dp[110][110];
//dfs(ia,ib)表示以a[ia]和b[ib]结尾的公共子串的长度
int dfs(int ia,int ib){
    if(ia<0||ib<0) return 0;
    if(dp[ia][ib]!=-1) return dp[ia][ib];
    if(a[ia]==b[ib]) return dp[ia][ib]=dfs(ia-1,ib-1)+1;
    else return dp[ia][ib]=0;

}
int main(){
    cin>>a>>b;
    la=strlen(a);
    lb=strlen(b);

    memset(dp,-1,sizeof(dp));
    for(int i=0;i<la;i++){
        for(int j=0;j<lb;j++){
            ans=max(ans,dfs(i,j));
        }
    }

    cout<<ans<<endl;
    return 0;
}

最后，推导动态转移方程

递归公式;

 if(a[ia]==b[ib]) return dp[ia][ib]=dfs(ia-1,ib-1)+1;
    else return dp[ia][ib]=0;

动态转移方程：

if(a[ia]==b[ib])  dp[ia][ib]=dp[ia-1][ib-1]+1;
    else dp[ia][ib]=0;

最终完整代码：

 

#include<iostream>
#include<cstring>
using namespace std;
char a[101],b[101];
int la,lb,ans;
int dp[110][110];
int main(){
    cin>>&a[1]>>&b[1];//数组的第一个元素通常用来存储空字符
                    //这样会从数组的第二个位置开始存储输入的字符串的内容
    la=strlen(&a[1]);//表示从数组的第二个元素开始计算字符串的长度
    lb=strlen(&b[1]);

    for(int i=1;i<=la;i++){
        for(int j=1;j<=lb;j++){
            if(a[i]==b[j])  dp[i][j]=dp[i-1][j-1]+1;
            else dp[i][j]=0;
            ans=max(ans,dp[i][j]);
        }
    }

    cout<<ans<<endl;
    return 0;
}

4>> 最长公共子序列

首先，运用递归的思想

#include<iostream>
#include<cstring>
using namespace std;
char a[101],b[101];
int la,lb,ans;
int dp[110][110];
//dfs表示数组a以ia结尾和数组b以ib结尾的最长公共子序列
int dfs(int ia,int ib){
    if(ia<0||ib<0)  return 0;
    if(a[ia]==b[ib]) return dfs(ia-1,ib-1)+1;
    else return max(dfs(ia-1,ib),dfs(ia,ib-1));
}
int main(){
    cin>>a>>b;
    cout<<dfs(strlen(a)-1,strlen(b)-1)<<endl;
    return 0;
}

其次，运用记忆化搜索优化

#include<iostream>
#include<cstring>
using namespace std;
char a[101],b[101];
int la,lb,ans;
int dp[110][110];
//dfs表示数组a以ia结尾和数组b以ib结尾的最长公共子序列
int dfs(int ia,int ib){
    if(ia<0||ib<0)  return 0;
    if(dp[ia][ib]!=0) return dp[ia][ib];
    if(a[ia]==b[ib]) return dp[ia][ib]=dfs(ia-1,ib-1)+1;
    else return dp[ia][ib]=max(dfs(ia-1,ib),dfs(ia,ib-1));
}
int main(){
    cin>>a>>b;

    cout<<dfs(strlen(a)-1,strlen(b)-1)<<endl;
    return 0;
}

 最后，由递归得出完整的动态转移方程

递归公式：

if(a[ia]==b[ib]) return dp[ia][ib]=dfs(ia-1,ib-1)+1;
    else return dp[ia][ib]=max(dfs(ia-1,ib),dfs(ia,ib-1));

动态转移方程：

if(a[ia]==b[ib]) dp[ia][ib]=dp[ia-1][ib-1]+1;
            else dp[ia][ib]=max(dp[ia][ib-1],dp[ia-1][ib]);

完整的代码：

#include<iostream>
#include<cstring>
using namespace std;
char a[101],b[101];
int ia,ib,ans;
int dp[110][110];
int main(){
    int la,lb;
    cin>>&a[1]>>&b[1];
    la=strlen(&a[1]);
    lb=strlen(&b[1]);

    for(int ia=1;ia<=la;ia++){
        for(int ib=1;ib<=lb;ib++){
            if(a[ia]==b[ib]) dp[ia][ib]=dp[ia-1][ib-1]+1;
            else dp[ia][ib]=max(dp[ia][ib-1],dp[ia-1][ib]);
        }
    }
    cout<<dp[la][lb]<<endl;
    return 0;
}