程序设计实践-动态规划

最新推荐文章于 2024-10-06 10:17:48 发布

Ykkk_

最新推荐文章于 2024-10-06 10:17:48 发布

阅读量123

点赞数

文章标签：动态规划 c++ 算法

本文链接：https://blog.csdn.net/Ykkk_/article/details/130213742

版权

本文通过一系列例子介绍了动态规划的应用，包括解决上楼梯的不同方式、找出数组中最大连续子序列和、确定最长递增子序列的长度、计算导弹拦截系统的最大拦截数量、求解最大上升子序列和以及在合唱队形排列和最长公共子序列等问题上的应用。

摘要由CSDN通过智能技术生成

动态规划

1、上楼梯问题

N阶楼梯上楼问题：一次可以走两阶或一阶，问有多少种上楼方式。（要求采用非递归）

输入描述：

输入包括一个整数N,(1<=N<90)。

输出描述：

可能有多组测试数据，对于每组数据，输出当楼梯阶数是N时的上楼方式个数。

示例1

输入：

输出：

#include <iostream>
using namespace std;

int main() {
    int n,dp[1000];
    cin>>n;
    dp[0]=0;
    dp[1]=1;
    dp[2]=2;
    for (int i=3; i<=n; i++) {
    dp[i]=dp[i-1]+dp[i-2];

    }
    cout<<dp[n];

}

2、最大连续子序列和

{A1,A2,…,An}中找到连续的子序列，使得和最大

思路：用dp[i]记录以A[i]结尾的连续序列的最大和。

有两种情况？

最大和的连续序列只有A[i]本身
有多个

#include <iostream>

using namespace std;
const int MAX = 1000000;

int main() {
    int n;
    int a[MAX], dp[MAX];
    while (cin >> n) {
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        for (int i = 0; i < n; i++) {
            if (i == 0)dp[i] = a[i];    //第一种情况
            else
                dp[i] = max(a[i], dp[i - 1] + a[i]); //第二种
        }
        int maxx = dp[0];
        for (int i = 0; i < n; i++) {
            if (dp[i] > maxx)
                maxx = dp[i];
        }
        cout << maxx << endl;
    }

    return 0;

}
// 64 位输出请用 printf("%lld")

思考怎么才能记录左右下标？？？？？

3、最长递增子序列

dp[i]表示以A[i]结尾的最长递增子序列的长度。那么要求的最长递增子序列的长度就是dp[i]的最大值。

两种情况：

A[i]比之前所有的都大，则dp[i]=1;

dp[i]=dp[j]+1

输入：

8
300 207 155 300 299 170 158 65   结果：2
1   1   1   2   2   1   2  1

KY77 拦截导弹问题

描述

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

输入描述：

每组输入有两行，第一行，输入雷达捕捉到的敌国导弹的数量k（k<=25），第二行，输入k个正整数，表示k枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。

输出描述：

每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

#include <iostream>
#include "cstdio"
using namespace std;
# define MAX 1000
int main() {
    int k, A[MAX], dp[MAX];
    cin >> k;
    dp[0] = 1;
    for (int i = 0; i < k; i++) {
        cin >> A[i];
    }
    for (int i = 0; i < k; i++) { //也可放到前面
        dp[i] = 1;
        for (int j = 0; j < i; j++) {
            if (A[i] <= A[j]) {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
    }
    int max = 0;
    for (int i = 0; i < k; i++) {
        if (dp[i] > max)
            max = dp[i];
    }
    cout << max;
}

KY78 最大上升子序列和

描述

一个数的序列bi，当b1 < b2 < … < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, …,aN)，我们可以得到一些上升的子序列(ai1, ai2, …, aiK)，这里1 <= i1 < i2 < … < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中序列和最大为18，为子序列(1, 3, 5, 9)的和. 你的任务，就是对于给定的序列，求出最大上升子序列和。注意，最长的上升子序列的和不一定是最大的，比如序列(100, 1, 2, 3)的最大上升子序列和为100，而最长上升子序列为(1, 2, 3)。

输入描述：

输入包含多组测试数据。每组测试数据由两行组成。第一行是序列的长度N (1 <= N <= 1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000（可能重复）。

输出描述：

对于每组测试数据，输出其最大上升子序列和。

示例1

输入：

7
1 7 3 5 9 4 8

输出：

问题就是 1 7 3 5 怎么知道是 1+3+5

解决：呃呃

如果前面有a[j]比a[i]小，则比较一下当前（a[i]?还是dp[i]）与加和的最大

但如果前面的都比A[i]大的话，那么在这个数位置的最大值就是他自己。

#include <iostream>
using namespace std;
#define MAX 10000
int main() {
    int N, A[MAX], dp[MAX];
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> A[i];
    }
    for (int i = 0; i < N; i++) {
        dp[i] = A[i];
        for (int j = 0; j < i; j++) {
            if (A[j] < A[i]) {
                dp[i] = max(dp[i], dp[j] + A[i]);//?为什么非得是dp？？？
              																	//dp[i]会更新
            }
        }
        
    }
 int max = 0;
    for (int i = 0; i < N; i++) {
        if (dp[i] > max)
            max = dp[i];
    }
    cout << max;

}
// 64 位输出请用 printf("%lld")

合唱队形

前后两次用动态规划

描述

N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学不交换位置就能排成合唱队形。合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1, 2, …, K，他们的身高分别为T1, T2, …, TK，则他们的身高满足T1 < T2 < … < Ti , Ti > Ti+1 > … > TK (1 <= i <= K)。你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

演示：   dp[i] = max(dp[i], dp[j] + 1)
        8
        186 186 150 200 160 130 197 220
        1   1    1   2  2   1   3    4
        3   3    2   3  2   1   1    1

#include <iostream>

using namespace std;
#define MAX 1000

int main() {
    int N, a[MAX];
    cin >> N;
    for (int i = 0; i < N; i++) {
        cin >> a[i];
    }
    //从左向右扫描
    int dp1[MAX];
    for (int i = 0; i < N; i++) {
        dp1[i] = 1;
        for (int j = 0; j < i; j++) {
            if (a[i] > a[j])
                dp1[i] = max(dp1[i], dp1[j] + 1);
        }
        // cout << "dp1[" << i << "]=" << dp1[i] << endl;
    }

    int dp2[MAX];
    for (int i = N - 1; i >= 0; i--) {
        dp2[i] = 1;
        for (int j = N - 1; j > i; j--) {
            if (a[i] > a[j]) {
                dp2[i] = max(dp2[i], dp2[j] + 1);
            }
        }
//        cout << "dp2[" << i << "]=" << dp2[i] << endl;
    }
    int maxx = 0;
    for (int i = 0; i < N; i++) {
        if (dp1[i] + dp2[i] > maxx)
            maxx = dp1[i] + dp2[i];
    }
    cout << N - maxx + 1;
}

最长公共子序列

描述：S1和S2，求一个最长公共子串S3，使他同时为S1和S2的子串，且长度最长

例如:

输入	结果
abcfbc abfcab programming contest abcd mnp	4 2 0

首先设置一个二维数组，dp[i][j]，代表以S1[i]作为结尾和以S2[j]作为结尾的最长公共子序列的长度。

要求的就是dp[n][m]的值

分情况考虑：

S1[i]=S2[j] 则必定存在一个最长公共子串以S1[i]和S2[j] 结尾， dp[i][j]=dp[i-1][j-1]+1
s1[i]!=s2[j] 那么dp[ i ][ j ]=max (dp[ i - 1 ][ j ],dp[ i ][ j - 1 ] )

#include <iostream>

using namespace std;
#define MAX 1000

int main() {
    int dp[MAX][MAX];
    string s1,s2;
    while(cin>>s1>>s2){
        int len1=s1.size();
        int len2=s2.size();
        for (int i = 1; i <= len1; ++i) {
            for (int j = 1; j <= len2; ++j) {
                if(s1[i-1]==s2[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;
    }
}