动态规划专题

最新推荐文章于 2022-02-19 18:20:41 发布

chenf0

最新推荐文章于 2022-02-19 18:20:41 发布

阅读量317

点赞数

分类专栏：学习记录

本文链接：https://blog.csdn.net/chenfang0529/article/details/100177078

版权

学习记录专栏收录该内容

63 篇文章 2 订阅

订阅专栏

问题1：数组划分

题目描述

一个数组中有若干正整数，将此数组划分为两个子数组，使得两个子数组各元素之和a,b的差最小，对于非法输入应该输出ERROR。

输入

数组中的元素

输出

降序输出两个子数组的元素和

样例输入

10 20 30 10 10
10 20 abc 10 10

样例输出

40 40
ERROR

#include<cstdio>
#include<stdio.h>
#include<iostream>
#include<set>
#include<algorithm>
#include<string>
#include<string.h>
#include<sstream>
using namespace std;
int num[10000000]={0};
int dp[10000000]={0};
int n,sum;
 int ma=0;
bool cmp(int a,int b){
	return a>b;
}


bool ifvalid(string a){
	int len=a.size();
	int i;
	for(i=0;i<len;i++){
		if(a[i]<'0'||a[i]>'9') return false;
	}
	return true;
}
void deal(string &str,int &flag,int &i,int &sum){
	string strr;
	while(str.find(" ")!=string::npos){
		strr=str.substr(0,str.find(" "));
		if(ifvalid(strr)==false){
			flag=1;
			return;
		}
		else{
			buf[i]=atoi(strr.c_str());
			sum+=buf[i++];
			str.erase(0,str.find(" ")+1);
		}
	}
	if(ifvalid(str)==false){
		flag=1;
		return;
	}
	else{
		buf[i]=atoi(str.c_str());
		sum+=buf[i++];
	}
	return;
}
int main(){
	int i,j,k;
	string str;
	while(getline(cin,str)!=NULL){
		i=1;
		int flag=0;
		int sum=0;
		memset(buf,0,sizeof(buf));
		memset(dp,0,sizeof(dp));
		deal(str,flag,i,sum);
		if(flag==1) cout<<"ERROR"<<endl;
		else{
			int sum2=sum/2;
			for(j=1;j<i;j++){//01背包
				//cout<<buf[j]<<endl;
				for(k=sum2;k>=buf[j];k--){
					dp[k]=max(dp[k],dp[k-buf[j]]+buf[j]);
				}
			}//从i-1个数字中挑选若干个，使其和不超过sum2，且尽量大
			cout<<dp[sum2]<<" "<<sum-dp[sum2]<<endl;
		}
	}
	return 0;

}

问题2:点菜问题

题目描述

北大网络实验室经常有活动需要叫外买，但是每次叫外买的报销经费的总额最大为C元，有N种菜可以点，经过长时间的点菜，网络实验室对于每种菜i都有一个量化的评价分数（表示这个菜可口程度），为Vi，每种菜的价格为Pi, 问如何选择各种菜，使得在报销额度范围内能使点到的菜的总评价分数最大。
注意：由于需要营养多样化，每种菜只能点一次。

输入

输入的第一行有两个整数C（1 <= C <= 1000）和N（1 <= N <= 100），C代表总共能够报销的额度，N>代表能点菜的数目。接下来的N行每行包括两个在1到100之间（包括1和100）的的整数，分别表示菜的>价格和菜的评价分数。

输出

输出只包括一行，这一行只包含一个整数，表示在报销额度范围内，所点的菜得到的最大评价分数。

样例输入

样例输出

5
30

#include<cstdio>
#include<algorithm>
using namespace std;
int vi[101]={0};//评分
int pi[101]={0};//价格
int dp[1001]={0};

int main(){
    int c, n,ma;
    while(scanf("%d %d",&c,&n)!=EOF){
        for(int i=0;i<n;i++){
        scanf("%d %d",&pi[i],&vi[i]);
    }
    //初始化
    for(int i=0;i<=c;i++){
        dp[i]=0;
    }

    ma=0; //最大评价分数
    for(int i=0;i<n;i++){
        for(int v=c;v>=pi[i];v--){  //必须逆序
            dp[v]=max(dp[v],dp[v-pi[i]]+vi[i]);
            if(ma<dp[v])
                ma=dp[v];
        }

    }

    printf("%d\n",ma);
    }


}

问题3: 放苹果

题目描述

把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

输入

第一行是测试数据的数目t（0 <= t <= 20）。以下每行均包含二个整数M和N，以空格分开。1<=M，N<=10。

输出

对输入的每组数据M和N，用一行输出相应的K。

样例输入

2
6 3
7 2

样例输出

7
4

解题分析：

设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，

当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m) f(m,n) = f(m,m)　　
当n<=m：不同的放法可以分成两类：

1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1);
2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即f(m,n) = f(m-n,n).
而总的放苹果的放法数目等于两者的和，即 f(m,n) =f(m,n-1)+f(m-n,n)

递归出口条件说明：

当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
当没有苹果可放时，定义为１种放法；

递归的两条路，第一条n会逐渐减少，终会到达出口n==1;
第二条m会逐渐减少，因为n>m时，我们会return f(m,m)　所以终会到达出口m==0

#include<cstdio>
#include<algorithm>
using namespace std;
int vi[101]={0};//评分
int pi[101]={0};//价格
int dp[1001]={0};
int apple(int m,int n){
    if(n==1)
        return 1;
    if(m==0)
        return 1;
    if(n>m)
        return apple(m,m);
    else{
        return apple(m,n-1)+apple(m-n,n);
    }

}


int main(){
    int t, n,m;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d",&m,&n);

        printf("%d\n",apple(m,n));

    }


}

问题 4：最大报销额

题目描述

现有一笔经费可以报销一定额度的发票。允许报销的发票类型包括买图书（A类）、文具（B类）、差旅（C类），要求每张发票的总额不得超过1000元，每张发票上，单项物品的价值不得超过600元。现请你编写程序，在给出的一堆发票中找出可以报销的、不超过给定额度的最大报销额。

输入

测试输入包含若干测试用例。每个测试用例的第1行包含两个正数 Q 和 N，其中 Q(Q<=2000) 是给定的报销额度，N（N<=30）是发票张数。随后是 N 行输入，每行的格式为：
m Type_1:price_1 Type_2:price_2 ... Type_m:price_m
其中正整数 m 是这张发票上所开物品的件数，Type_i 和 price_i 是第 i 项物品的种类和价值。物品种类用一个大写英文字母表示。当N为0时，全部输入结束，相应的结果不要输出。

输出

对每个测试用例输出1行，即可以报销的最大数额，精确到小数点后2位。

样例输入

300.00 3
2 A:33.50 B:150.00
1 C:850.00
3 A:159.99 A:350.00 X:10.00
1100.00 2
2 B:600.00 A:400.00
1 C:300.50
150.00 0

样例输出

183.50
1000.00

提示

首先要按照题目的要求计算后判断每张发票的有效性，接着是一个动态规划算法（没见过类似题目的同学可以搜一下“背包问题”），对于此题，由于题目交代了所有金额都只到小数点后两位，因此乘以100后即是整数，从而可以转化为01背包问题，用dp[i]表示到达总金额为i的有效性。

问题 5: 毕业bg

题目描述

每年毕业的季节都会有大量毕业生发起狂欢，好朋友们相约吃散伙饭，网络上称为“bg”。参加不同团体的bg会有不同的感觉，我们可以用一个非负整数为每个 bg定义一个“快乐度”。现给定一个bg列表，上面列出每个bg的快乐度、持续长度、bg发起人的离校时间，请你安排一系列bg的时间使得自己可以获得最大的快乐度。

例如有4场bg：
第1场快乐度为5，持续1小时，发起人必须在1小时后离开；
第2场快乐度为10，持续2小时，发起人必须在3小时后离开；
第3场快乐度为6，持续1小时，发起人必须在2小时后离开；
第4场快乐度为3，持续1小时，发起人必须在1小时后离开。
则获得最大快乐度的安排应该是：先开始第3场，获得快乐度6，在第1小时结束，发起人也来得及离开；再开始第2场，获得快乐度10，在第3小时结束，发起人正好来得及离开。此时已经无法再安排其他的bg，因为发起人都已经离开了学校。因此获得的最大快乐度为16。

注意bg必须在发起人离开前结束，你不可以中途离开一场bg，也不可以中途加入一场bg。
又因为你的人缘太好，可能有多达30个团体bg你，所以你需要写个程序来解决这个时间安排的问题。

输入

测试输入包含若干测试用例。每个测试用例的第1行包含一个整数N (<=30)，随后有N行，每行给出一场bg的信息：
h l t
其中 h 是快乐度，l是持续时间（小时），t是发起人离校时间。数据保证l不大于t,因为若发起人必须在t小时后离开，bg必须在主人离开前结束。

当N为负数时输入结束。

输出

每个测试用例的输出占一行，输出最大快乐度。

样例输入

样例输出

7
16

#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
struct Bg{
    int h;//快乐度
    int l;//持续时间
    int t;//离校时间
}bg[31];

bool cmp(Bg a,Bg b){
	return (a.t<b.t);
}

int m[10000]={0};

int  main()
{
    int n,happ,ma;
    while(scanf("%d",&n)!=EOF){
        if(n<0){
            break;
        }
        ma=0;

        for(int i=0;i<n;i++){
            scanf("%d%d%d",&bg[i].h,&bg[i].l,&bg[i].t);
            if(ma<bg[i].t)
                ma=bg[i].t;
        }
        sort(bg,bg+n,cmp);
        for(int k=0;k<=ma;k++){
            m[k]=0;
        }
        for(int i=0;i<n;i++){
            for(int j=bg[i].t;j>=bg[i].l;j--){
              m[j]=max(m[j],m[j-bg[i].l]+bg[i].h);

            }
        }
      happ=0;
       for(int i=1;i<=ma;i++){
            if(m[i]>happ)
                happ=m[i];
        }

         printf("%d\n",happ);


    }

}

问题 6: 最大子矩阵

题目描述

已知矩阵的大小定义为矩阵中所有元素的和。给定一个矩阵，你的任务是找到最大的非空(大小至少是1 * 1)子矩阵。
比如，如下4 * 4的矩阵

0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2

的最大子矩阵是

9 2
-4 1
-1 8

这个子矩阵的大小是15。

输入

输入是一个N * N的矩阵。输入的第一行给出N (0 < N <= 100)。
再后面的若干行中，依次（首先从左到右给出第一行的N个整数，再从左到右给出第二行的N个整数……）给出矩阵中的N2个整数，整数之间由空白字符分隔（空格或者空行）。
已知矩阵中整数的范围都在[-127, 127]。

输出

测试数据可能有多组，对于每组测试数据，输出最大子矩阵的大小。

样例输入

样例输出

27
78

#include <cstdio>
const int maxn=110;
int a[maxn][maxn];
int b[maxn];

int main()
{
    int j,k,i,n,t,ma,c,sum=0;

    while(scanf("%d",&n)!=EOF){
            sum=0;
        for (i=1;i<=n;i++){
            for (j=1;j<=n;j++){
                scanf("%d",&a[i][j]);
            }
        }
        ma=a[1][1];//初值不能设为0，可能出现矩阵全为负数

    for ( i=1;i<=n;i++)
    {


        for(int a=0;a<=n;a++){
            b[a]=0;
        }

        for ( j=i;j<=n;j++)
        {
            for (k=1;k<=n;k++)
                b[k]=b[k]+a[j][k];  //求每一段和；
            c=0;
            for (t=1;t<=n;t++)
            {
                if (c>0)
                    c=c+b[t];
                else
                    c=b[t];
                if (c>ma)
                    ma=c;
            }

        }
    }
    printf("%d\n",ma);
    }

    return 0;
}

问题 7: 拦截导弹

题目描述

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

输入

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

输出

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

样例输入

4
9 6 7 8
7
4 5 6 7 13 42 3
5
6 5 4 3 5
0

样例输出

2
2
4

#include<stdio.h>
#include<algorithm>

using namespace std;
int k[30];
int dp[30];

int main(){
  int n,ma;
  while(scanf("%d",&n)!=EOF){
    if(n==0)
        break;
    ma=1;
    for(int i=0;i<n;i++){
        scanf("%d",&k[i]);
        dp[i]=1;
    }

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

    }

    for(int i=0;i<n;i++){
        if(ma<dp[i])
            ma=dp[i];
    }
    printf("%d\n",ma);
  }


}

问题8：最长公共子序列（LCS）

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=10001;
int dp[maxn][maxn];
char a[maxn];
char b[maxn];
int main(){
    gets(a+1);
    gets(b+1);
    int lenA=strlen(a+1);
    int lenB=strlen(b+1);
    for(int i=0;i<=lenA;i++){
       dp[i][0]=0;
    }
    for(int j=0;j<=lenB;j++){
       dp[0][j]=0;
    }

    for(int i=1;i<=lenA;i++){
        for(int j=1;j<=lenB;j++){
            if(a[i]==b[j]){
                dp[i][j]=dp[i-1][j-1]+1;
            }else{
                dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
    }
     printf("%d\n",dp[lenA][lenB]);
}

1.最大连续子序列和

2.最长不下降子序列（LIS）

3.最长公共子序列（LCS）

4.最长回文子串

5.数塔DP

6.DAG最长路

7.背包问题

01背包
完全背包

chenf0

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
动态规划专题

目录问题1：数组划分问题2:点菜问题问题3: 放苹果问题 4：最大报销额问题 5: 毕业bg问题 6: 最大子矩阵问题 7: 拦截导弹问题8：最长公共子序列（LCS）问题1：数组划分题目描述一个数组中有若干正整数，将此数组划分为两个子数组，使得两个子数组各元素之和a,b的差最小，对于非法输入应该输出ERROR。输入数组中的元素输出降序输...
复制链接

扫一扫