KuangBin专题12 基础DP1 1-9

KuangBin专题12 基础DP1

1.Max Sum Plus Plus
输入一个m，n分别表示成m组，一共有n个数即将n个数分成m组，m组的和加起来得到最大值并输出。

解题思路：状态dp[i][j]表示前j个数分成i组的最大值。

动态转移方程：dp[i][j]=max(dp[i][j-1]+a[j],max(dp[i-1][k])+a[j]) (0<k<j)

dp[i][j-1]+a[j]表示的是前j-1分成i组，第j个必须放在前一组里面。

max( dp[i-1][k] ) + a[j] )表示的前（0<k<j）分成i-1组，第j个单独分成一组。

但是题目的数据量比较到，时间复杂度为n^3，n<=1000000，显然会超时，继续优化。

max( dp[i-1][k] ) 就是上一组 0…j-1 的最大值。我们可以在每次计算dp[i][j]的时候记录下前j个
的最大值 用数组保存下来 ，这样时间复杂度为 n^2。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1e6+10;
const int INF=0x3f3f3f3f;
int a[maxn];
int dp[maxn];
int Max[maxn];
int main(){
	int n,m,mmax;
	while(~scanf("%d%d",&m,&n)) {
		for(int i=1;i<=n;i++){
			scanf("%d",&a[i]);
		}
		memset(dp,0,sizeof(dp));
		memset(Max,0,sizeof(Max));
		for(int i=1;i<=m;i++){
			mmax=-INF;
			for(int j=i;j<=n;j++){
				dp[j]=max(dp[j-1]+a[j],Max[j-1]+a[j]);
				Max[j-1]=mmax;
				mmax=max(mmax,dp[j]);
			}
		}
		printf("%d\n",mmax);
	}
}

2.Ignatius and the Princess IV
给一列数，找出出现（n+1）/2次的数字 水题

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
int main(){
	int n;
	int dp[100005]={0};
	while(scanf("%d",&n)!=EOF){
		memset(dp,0,sizeof(dp));
		int flag=0;
		int k;
		for(int t=0;t<n;t++){
			scanf("%d",&k);
			dp[k]++;
			if(dp[k]>=(n+1)/2) {
				if(flag==0) {
					printf("%d\n",k);
				}
				flag=1;
			}
		}
	}
}

3.Monkey and Banana
题意：M种长方体，计算最高能堆多高。
要求位于上面的长方体的长要大于下面长方体的长，上面长方体的宽大于下面长方体的宽
其实就是把长方体的可变情况列举一下 是最大上升子序列问题的变种

#include<iostream>
#include<algorithm>
using namespace std;
struct chang{
	int l,w,h;
}cd[100];
int dp[100];
bool cmp(chang a,chang b){
	if(a.l==b.l) return a.w<b.w;
	return a.l<b.l;
} 
int main(){
	int a,b,c;
	int case1=1;
	int n;
	while(cin>>n&&n){
		int len=0;
		for(int i=0;i<n;i++){
			cin>>a>>b>>c;
			cd[len].h=a,cd[len].l=b>c?b:c,cd[len++].w=b>c?c:b;
			cd[len].h=b,cd[len].l=a>c?a:c,cd[len++].w=a>c?c:a;
			cd[len].h=c,cd[len].l=a>b?a:b,cd[len++].w=a>b?b:a;
		}
		sort(cd,cd+len,cmp);
		dp[0]=cd[0].h;
		int max_h;
		for(int i=1;i<len;i++){
			max_h=0;
			for(int j=0;j<i;j++){
				if(cd[j].l<cd[i].l&&cd[j].w<cd[i].w){
					max_h=max_h>dp[j]?max_h:dp[j];
				}
			}
			dp[i]=cd[i].h+max_h;
		}
		cout<<"Case "<<case1++<<": maximum height = "<<*max_element(dp,dp+len)<<endl;
	}
}

4.Doing Homework
有n个任务，每个任务有一个截止时间，超过截止时间一天，要扣一个分。
求如何安排任务，使得扣的分数最少

5.Super Jumping! Jumping! Jumping!
在长度为n的序列中求上升子序列的最大的字段和。
我们可以模仿求最长上升子序列的方法，遍历整个数组，每次找 确定元素前的最大和，维护最大值即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
int num[1010],dp[1010];
int main(){
	int n;
	while(~scanf("%d",&n)&&n){
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=n;i++){
			scanf("%d",&num[i]);
		}
		num[0]=0;
		int maxx=-1;
		for(int i=1;i<=n;i++){
			int maxs=-1;
			for(int j=0;j<i;j++){
				if(num[i]>num[j]) maxs=max(maxs,dp[j]);
			}
			dp[i]=maxs+num[i];
			maxx=max(maxx,dp[i]);
		}
		cout<<maxx<<endl;
	}
}

6.Piggy-Bank

7.免费馅饼
感觉跟4有点像
8.Tickets

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
void time(int a){
	int h,m,s;
	s=a%60;
	a=a/60;
	m=a%60;
	h=a/60+8;
	h=h%24;
	if(h<=12) printf("%02d:%02d:%02d am\n",h,m,s);
	else printf("%02d:%02d:%02d pm\n",h-12,m,s);
}
int main(){
	int n,k;
	int dp[2001];
	cin>>n;
	while(n--){
		cin>>k;
		int si[2001],di[2001];
		memset(si,0,sizeof(si));
		memset(di,0,sizeof(di));
		for(int i=1;i<=k;i++) {
			scanf("%d",&si[i]);
		}
		for(int i=1;i<=k-1;i++){
			scanf("%d",&di[i]);
		}
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=k;i++){
			if(i==1) dp[i]=si[i];
			else if(i==2) dp[i]=min(dp[i-1]+si[i],di[i-1]);
			else dp[i]=min(dp[i-1]+si[i],dp[i-2]+di[i-1]);
		}
		time(dp[k]);
	}
}

9.最少拦截系统
给出一组数，表示按顺序飞来的导弹的高度。有一种导弹拦截系统，拦截的第一枚导弹可以是无限高度，但是之后可以拦截的导弹高度必须是递减的，问最少需要多少个这样的拦截系统才能全部拦截。
答案其实就只是一个最长上升子序列的个数

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1007;
int a[N],dp[N];
int LIS(int n){
	int res=0;
	for(int i=0;i<n;i++){
		for(int j=0;j<i;j++){
			if(a[j]<a[i]) {
				dp[i]=max(dp[j]+1,dp[i]);
			}
		}
		res=max(dp[i],res);
	}
	return res;
}
int main(){
	int n;
	while(cin>>n){
		for(int i=0;i<n;i++) {
			cin>>a[i];
			dp[i]=1;
		}
		cout<<LIS(n)<<endl;
	}
}