dp入门 2021-2-8

dp要开始了吼QwQ

记录学习历程，写写自己的理解(´･Д･)」

例题1、
数字三角形
poj1163 The Triangle

方法1:
递归的思想
设点为D(i,j)，i/j从1开始，每次取max(maxsum(i+1,j),maxsum(i+1,j+1))，开始递归。
这样写容易理解，但是复杂度巨大，必超时。

方法2:
为了避免重复计算，每次都记录算好的值。
代码实现：

int D[105][105];
int maxsum[105][105];
int n;
int Maxsum(int i,int j)
{
    if(maxsum[i][j]!=-1){
        return maxsum[i][j];
    }
    else{
        if(i==n){
            return D[i][j];
        }
        int x=Maxsum(i+1,j);
        int y=Maxsum(i+1,j+1);
        return max(x,y)+D[i][j];
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            cin>>D[i][j];
            maxsum[i][j]=-1;
        }
    }
    cout<<Maxsum(1,1)<<endl;
}

这段代码交到oj上会tle
但是这个如果层数多，会爆栈，直接RE。

方法3:
用递推实现，这样就不会存在递归爆栈了
ac代码实现：

int D[105][105];
int maxsum[105][105];
int n;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=i;j++){
            cin>>D[i][j];
        }
    }
    for(int i=1;i<=n;i++){
        maxsum[n][i]=D[n][i];
    }
    for(int i=n-1;i>=1;i--){
        for(int j=1;j<=i;j++){
            maxsum[i][j]=max(maxsum[i+1][j],maxsum[i+1][j+1])+D[i][j];
        }
    }
    cout<<maxsum[1][1]<<endl;
}

动态规划一般思路：
1、将原问题分解为子问题
2、确定状态，某状态的值对应相应子问题的解
3、确定初始边界状态
4、确定状态转移方程
可以用dp解决的问题通常有以下特点：

例题2、
求一个序列中的最长上升子序列的长度
百练2757 最长上升子序列
1、找子问题
计算出以序列中所有元素为终点的子序列长度，然后寻找最大值
2、状态转移方程
dp[i]=max(dp[i-1],dp[i-2]…,dp[1],0)+1
ac代码：

int a[1010];
int dp[1010];//状态记录
int n;
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    dp[1]=1;//边界问题的解
    for(int i=2;i<=n;i++){
        int max=0;
        for(int j=1;j<=i;j++){
            if(max<dp[j]&&a[i]>a[j]){
                max=dp[j];
            }
        }
        dp[i]=max+1;//状态转移
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        if(ans<dp[i]){
            ans=dp[i];
        }
    }
    cout<<ans<<endl;
}

例题3、求最长公共子序列
poj1458
Common Subsequence

int main()
{
    char a[1010],b[1010];
    while(~scanf("%s%s",a,b)){
        int dp[1010][1010];
        int s1=(int)strlen(a);
        int s2=(int)strlen(b);
        for(int i=0;i<=s1;i++){
            dp[i][0]=0;
        }
        for(int j=0;j<=s2;j++){
            dp[0][j]=0;
        }
        for(int i=1;i<=s1;i++){
            for(int j=1;j<=s2;j++){
                if(a[i-1]==b[j-1]){
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else{
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        cout<<dp[s1][s2]<<endl;
    }
}

个人总结一下，动态规划核心思想就是通过状态转移的条件，利用已知状态计算未知状态。

贴一个题目，集训队选拔周赛A题，运用状态转移思想，判断某状态能否达到。

ac代码：

int dp[3000][3000];
int calc_s(double a, double b, double c)
{
    if (a+b <= c || a+c <= b || b+c <= a)
        return -1;
    double p = (a + b + c) / 2.0;
    return sqrt(p*(p - a)*(p - b)*(p - c));
}
int main()
{
    int n;
    cin>>n;
    int a[60];
    int sum=0;
    for(int i=1;i<=n;i++){
        cin>>a[i];
        sum+=a[i];
    }
    int half=sum/2+((sum & 1) == 0);
    memset(dp,0,sizeof(dp));
    dp[0][0]=1;
    for(int k=1;k<=n;k++){
        for(int i=half+1;i>=0;i--){
            for(int j=half+1;j>=0;j--){
                if(i-a[k]>=0&&dp[i-a[k]][j]){
//                    cout<<"i="<<i<<" j="<<j<<endl;
//                    cout<<"i-a[k]="<<i-a[k]<<endl;
                    dp[i][j]=1;
                }
                if(j-a[k]>=0&&dp[i][j-a[k]]){
//                    cout<<"i="<<i<<" j="<<j<<endl;
//                    cout<<"j-a[k]="<<j-a[k]<<endl;
                    dp[i][j]=1;
                }
            }
        }
    }
    int ans=-1;
    for(int i=half;i>=0;i--){
        for(int j=i;j>=0;j--){
            if(dp[i][j]){
//                cout<<"i="<<i<<" j="<<j<<" sum-i-j="<<sum-i-j<<endl;
                ans=max(ans,calc_s(i,j,sum-i-j));
//                cout<<"s="<<calc_s(i,j,sum-i-j)<<endl;
            }
        }
    }
    cout<<ans<<endl;
}

去掉备注//可以看如何标记状态转移。