王道考研复试机试题解 2020版--第十二章动态规划(1)

最新推荐文章于 2021-01-28 15:38:48 发布

原创最新推荐文章于 2021-01-28 15:38:48 发布 · 299 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

机试专栏收录该内容

19 篇文章

订阅专栏

本文深入探讨了五种经典动态规划算法：N阶楼梯上楼问题、吃糖果问题、最大序列和、最大子矩阵和最大连续子序列。通过具体代码实现，详细解析了每种算法的原理与应用，为读者提供了全面的动态规划算法学习资源。

1.N阶楼梯上楼问题

#include<iostream>
using namespace std;

const int maxn=90;

int main(){
    int dp[maxn];
    
    for(int i=0;i<maxn;i++){
        if(i==0)dp[i]=0;
        else if(i==1)dp[i]=1;
        else{
            dp[i]=dp[i-1]+dp[i-2];
        }
    }
    int n;
    while(cin>>n){
        cout<<dp[n+1]<<endl;;
    }
    return 0;
}

2.吃糖果

#include<iostream>
using namespace std;

const int maxn=90;

int main(){
    int dp[maxn];
    
    for(int i=0;i<maxn;i++){
        if(i==0)dp[i]=0;
        else if(i==1)dp[i]=1;
        else{
            dp[i]=dp[i-1]+dp[i-2];
        }
    }
    int n;
    while(cin>>n){
        cout<<dp[n+1]<<endl;;
    }
    return 0;
}

3.最大序列和

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

const int maxn=1000000;


long long arr[maxn];
long long dp[maxn];

long long MaxSubsequence(int n){
    long long maximum=-99999;
    for(int i=0;i<n;i++){
        if(i==0){
            dp[i]=arr[i];
        }else {
            dp[i]=max(arr[i],dp[i-1]+arr[i]);
        }
        //cout<<dp[i]<<endl;
        maximum=max(maximum,dp[i]);
        //cout<<maximum<<endl;
    }
    return maximum;
}

int main(){
    int n;
    while(cin>>n){
        for(int i=0;i<n;i++){
            cin>>arr[i];
        }
        long long answer=MaxSubsequence(n);
        cout<<answer<<endl;
    }
    return 0;
}

4.最大子矩阵

#include<iostream>
using namespace std;
const int maxn=100;
int matrix[maxn][maxn];  //原始矩阵
int total[maxn][maxn];   //辅助矩阵
int arr[maxn];
int dp[maxn];

int MaxSubsequence(int n){
    int maximum=-9999;
    for(int i=0;i<n;i++){
        if(i==0){
            dp[i]=arr[i];
        }
        else{
            dp[i]=max(arr[i],dp[i-1]+arr[i]);
        }
        maximum=max(maximum,dp[i]);
    }
    return maximum;
}

int MaxSubmatrix(int n){
    int maximal=-9999;
    for(int i=0;i<n;i++){
        for(int j=i;j<n;j++){
            for(int k=0;k<n;k++){
                if(i==0)
                    arr[k]=total[j][k];
                else
                    arr[k]=total[j][k]-total[i-1][k];
            }
            int current=MaxSubsequence(n);
            maximal=max(maximal,current);
        }
        
    }
    return maximal;
}

int main(){
    int n;
    while(cin>>n){
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cin>>matrix[i][j];
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==0)
                    total[i][j]=matrix[i][j];
                else
                    total[i][j]=total[i-1][j]+matrix[i][j];
            }
        }
        int answer =MaxSubmatrix(n);
        cout<<answer<<endl;
    }
    return 0;
}

5.最大连续子序列

#include<iostream>
using namespace std;

const int maxn=10000;
struct sequence{  //序列结构
    int first;
    int end;
    int value;
};

sequence dp[maxn];
int arr[maxn];

sequence MaxSubsequence(int n){
    sequence maxse;
    maxse.first=0;
    maxse.end=0;
    maxse.value=-99999;
    for(int i=0;i<n;i++){
        if(i==0){
            dp[i].first=arr[i];
            dp[i].end=arr[i];
            dp[i].value=arr[i];
        }
        else{
            if(arr[i]>dp[i-1].value+arr[i]){
                dp[i].value=arr[i];
                dp[i].first=arr[i];
                dp[i].end=arr[i];
            }
            else{
                dp[i].value=dp[i-1].value+arr[i];
                dp[i].first=dp[i-1].first;
                dp[i].end=arr[i];
            }
            
        }
        if(maxse.value<dp[i].value){
            maxse=dp[i];
        }
        
    }
    return maxse;
}

int main(){
    int n;
    while(cin>>n&&n!=0){
        bool flag=false;
        for(int i=0;i<n;i++){
             cin>>arr[i];
             if(arr[i]>=0)flag=true;
        }
        if(!flag){
            cout<<0<<" "<<arr[0]<<" "<<arr[n-1]<<endl;
            continue;
        }
        
        sequence maxsequence=MaxSubsequence(n);
        cout<<maxsequence.value<<" "<<
            maxsequence.first<<" "<<maxsequence.end<<endl;
    }
    return 0;
}