dp常见问题

  1. poj1163
    http://poj.org/problem?id=1163
    数塔
    dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+a[i][j];
#include <iostream>
#include <cstring>
using namespace std;

int a[105][105];
int dp[105][105];

int main()
{
    int n;
    while(cin>>n)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                cin>>a[i][j];
                dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+a[i][j];
            }
        }
        int ans=-1;
        for(int i=1;i<=n;i++)
        {
            if(ans<dp[n][i])
            ans=dp[n][i];
        }
        cout<<ans<<endl;
    }
    return 0;
}

可以只用一维数组存本次最优解,节省了空间

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

int a[105][105];
int dp[105];

int main()
{
    int n;
    while(cin>>n)
    {
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                cin>>a[i][j];
            }
        }
        for(int i=1;i<=n;i++)
        dp[i]=a[n][i];
        for(int i=n-1;i>=0;i--)
        {
            for(int j=1;j<=i;j++)
            {
                dp[j]=max(dp[j],dp[j+1])+a[i][j];
            }
        }
        cout<<dp[1]<<endl;
    }
    return 0;
}
  1. 最长连续子序列
    hdu1231
    dp[i]是以i结尾的最长连续子序列,
    dp[i]=max(dp[i-1]+a[i],a[i]);
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxn=10005;

int a[maxn];
int dp[maxn];
int pos[maxn];//pos[i],以i结尾序列的起始点
int n;

int main()
{
    while(cin>>n&&n)
    {
        memset(dp,0,sizeof(dp));
        memset(pos,0,sizeof(pos));
        for(int i=0;i<n;i++)
        cin>>a[i];
        int ans=-1;
        for(int i=0;i<n;i++)
        {
            if(dp[i-1]<=0)
            pos[i]=a[i];
            else
            pos[i]=pos[i-1];
            dp[i]=max(a[i],dp[i-1]+a[i]);
            ans=max(ans,dp[i]);
        }
        if(ans<0)
        {
            printf("0 %d %d\n",a[0],a[n-1]);
            continue;
        }
        for(int i=0;i<n;i++)
        {
            if(dp[i]==ans)
            {
                printf("%d %d %d\n",dp[i],pos[i],a[i]);
                break;
            }
        }
    }
    return 0;
}

hdu1003一样,只是记录下标

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int maxn=100005;

int a[maxn];
int dp[maxn];
int pos[maxn];

int main()
{
    int t;
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++)
    {
        memset(dp,0,sizeof(dp));
        memset(pos,0,sizeof(pos));
        int n;
        int ans=-100000000;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
        for(int i=0;i<n;i++)
        {
            if(dp[i-1]<0)
            pos[i]=i;
            else
            pos[i]=pos[i-1];
            dp[i]=max(dp[i-1]+a[i],a[i]);
            ans=max(ans,dp[i]);
        }
        for(int i=0;i<n;i++)
        {
            if(ans==dp[i])
            {
                printf("Case %d:\n",cas);
                printf("%d %d %d\n",ans,pos[i]+1,i+1);
            }
        }
        if(cas!=t)
        printf("\n");
    }
    return 0;
}
  1. 最长递增子序列
    原文:http://blog.csdn.net/qq_34681949/article/details/52186675
    一.O(n*n)算法,dp[i]表示以ai为末尾的最长上升子序列的长度,而以ai结尾的最长上升子序列有两种:
1.只包含ai的子序列;  2.在满足j<i且aj<ai的以aj为结尾的上升子序列末尾,追加上ai得到的子序列。
所以有如下递推关系:

dp[i]=max{1,dp[j]+1|j<i且aj<ai} 
#include<stdio.h> 
#include<string.h> 
#include<algorithm> 
using namespace std;  
int a[10010];  
int dp[10010];  
int main()  
{  
    int n;  
    while(scanf("%d",&n)!=EOF)  
    {  
        for(int i=0;i<n;i++)  
        {  
            scanf("%d",&a[i]);  
            dp[i]=1;  
        }  
        int ans=0;  
        for(int i=1;i<n;i++)  
        {  
            for(int j=0;j<i;j++)  
            {  
                if(a[j]<a[i])  
                {  
                    dp[i]=max(dp[j]+1,dp[i]);  
                }  
            }  
            ans=max(ans,dp[i]);  
        }  
        printf("%d\n",ans);  
    }  
    return 0;  
 }   

二.O(nlogn)算法,dp[i]=长度为i+1的上升子序列中末尾元素的最小值(不存在的话就是INF)
这种算法中,运用STL中的lower_bound()函数很方便。

#include<stdio.h> 
#include<string.h> 
#include<algorithm> 
using namespace std;  
#define INF 0x3f3f3f 
int dp[10010];//dp[i]表示长度为i+1的子序列末尾元素最小值; 
int a[10010];  
int main()  
{  
    int n;  
    while(scanf("%d",&n)!=EOF)  
    {  
        for(int i=0;i<n;i++)  
        {  
            scanf("%d",&a[i]);  
            dp[i]=INF;//不可以用memset对数组赋值INF,只能赋值0或-1; 
                      //可以用fill(dp,dp+n,INF); 
        }  
        for(int i=0;i<n;i++)  
        {  
            *lower_bound(dp,dp+n,a[i])=a[i];//找到>=a[i]的第一个元素,并用a[i]替换; 
        }  
        printf("%d\n",lower_bound(dp,dp+n,INF)-dp);//找到第一个INF的地址减去首地址就是最大子序列的长度; 
    }  
    return 0;  
}  

hdu1257 最长非递增子序列
http://acm.hdu.edu.cn/submit.php?pid=1257

dp[i]=max(dp[i],dp[j]+1) ( 0<=j

#include <iostream>
#include <cstdio>

using namespace std;

const int maxn=1010;

int a[maxn];
int dp[maxn];

int main()
{
    int n;
    while(scanf("%d",&n)!=-1)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            dp[i]=1;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                if(a[i]>a[j])
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++)
        ans=max(ans,dp[i]);
        printf("%d\n",ans);
    }
    return 0;
}

4.最长公共子序列
dp[i,j] = 0 i=0 || j=0
dp[i,j] = dp[i-1][j-1]+1 i>0,j>0, a[i] = b[j]
dp[i,j] = max(dp[i-1][j],dp[i][j-1]) i>0,j>0, a[i] != b[j]

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

char a[1005],b[1005];
int dp[1005][1005];

int main()
{
    while(cin>>a>>b)
    {
        int len1=strlen(a);
        int len2=strlen(b);
        memset(dp,0,sizeof(dp));
        for(int i=1; i<=len1; i++)
            for(int j=1; j<=len2; 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[len1][len2]<<endl;
    }
    return 0;
}
  1. 最长回文子序列
    最长回文子序列 LPS(Longest Palindromic Subsequence),该问题为动态规划的
    经典题目。分析后可以得到该问题的实质如下:
    对任意字符串,如果头和尾相同,那么它的最长回文子序列一定是去头去尾之后
    的部分的最长回文子序列加上头和尾。如果头和尾不同,那么它的最长回文子序
    列是去头的部分的最长回文子序列和去尾的部分的最长回文子序列的较长的那
    一个。
    转化为 DP 的状态转移方程如下:
    设字符串为s,dp[ i ][ j ]表示s[i….j]的LPS;
    状态转移方程:
    当 i > j 时,dp[ i ][ j ]=0;
    当 i = j 时,dp[ i ][ j ]=1;
    当 i < j 且s[ i ] = s[ j ] 时,dp[ i ][ j ] = dp[ i-1 ][ j-1]+2;
    当 i < j 且s[ i ] != s[ j ] 时,dp[ i ][ j ] = max( dp[ i+1][ j ] , dp[ i ][ j-1] );

时间复杂度O(n*n),只适合数据较小时,较大时马拉车

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

int dp[400][400];

void LPS(char s[],int len)
{
    for(int i=len-1;i>=0;i--)
    {
        dp[i][i]=1;
        for(int j=i+1;j<len;j++)
        {
            if(s[i]==s[j])
            dp[i][j]=dp[i+1][j-1]+2;
            else
            dp[i][j]=max(dp[i+1][j],dp[i][j-1]);
        }
    }
}
int main()
{
    char s[305];
    while(cin>>s)
    {
        memset(dp,0,sizeof(dp));
        int len=strlen(s);
        LPS(s,len);
        cout<<dp[0][len-1]<<endl;
    }
    return 0;
}
    原文作者:B树
    原文地址: https://blog.csdn.net/aonaigayiximasi/article/details/79392864
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注