[kuangbin带你飞]专题十二基础DP1

最新推荐文章于 2020-03-28 10:56:19 发布

zzti_xiaowei

最新推荐文章于 2020-03-28 10:56:19 发布

阅读量187

点赞数

分类专栏： Acm--动态规划简单dp

本文链接：https://blog.csdn.net/zzti_xiaowei/article/details/82219395

版权

Acm--动态规划同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

简单dp

7 篇文章 0 订阅

订阅专栏

Hdu-1024 Max Sum Plus Plus

经典dp：最大M字段和
dp[i][j]:表示以a[j]结尾的前j个元素分成i组的最大和。
它的取值有两种可能：

(x1,y1) (x2,y2) … (xi,yi,a[j]) // a[j]加前i组合为第i组
(x1,y1) (x2,y2) … (xi-1,yi-1) (a[j]) // a[j]单独属于第i组

故状态转移方程：dp[i][j]=max(dp[i][j-1],dp[i-1][k])+a[j] i<=k<=j-1
优化：用pre[j-1]记录dp[i-1][k](i<=k<=j-1)的最大值。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=1e6+10;

int n,m;
int a[Max_n],pre[Max_n];
int dp[Max_n];   

int main()
{
	while(~scanf("%d%d",&m,&n)){
		for(int i=1;i<=n;i++)scanf("%d",&a[i]);
		memset(dp,0,sizeof(dp));
		memset(pre,0,sizeof(pre));
		int tmp;
		for(int i=1;i<=m;i++){
			tmp=-inf;
			for(int j=i;j<=n;j++){
				dp[j]=max(dp[j-1],pre[j-1])+a[j];
				pre[j-1]=tmp;
				tmp=max(tmp,dp[j]);
			}
		}
		printf("%d\n",tmp);
	}
	return 0;
}

Hdu-1029 Ignatius and the Princess IV

// 简单桶排序，dp[i]记录数字i出现的次数
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1e6+10;

int n;
int dp[Max_n];

int main()
{
	while(~scanf("%d",&n)){
		memset(dp,0,sizeof(dp));
		int c,f;
		for(int i=0;i<n;i++){
			scanf("%d",&c);
			dp[c]++;
			if(dp[c]>=(n+1)/2)f=c;
		}
		printf("%d\n",f);
	}
	return 0;
}

Hdu-1069 Monkey and Banana

// 先求出每个积木的六种摆放方式，然后排序后求最大递增子序列。
// dp[i]：表示第i个积木可搭的最大高度。
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1100;

int n,t=0;
struct edge{
	int x,y,z;
	bool operator<(const edge& e)const{
		if(x!=e.x)return x<e.x;
		return y<e.y;
	}
}e[Max_n];
int dp[Max_n];

int main()
{
	while(~scanf("%d",&n)&&n){
		int a,b,c;
		for(int i=0;i<n;i++){
			scanf("%d%d%d",&a,&b,&c);
			e[i*6].x=a,e[i*6].y=b,e[i*6].z=c;
			e[i*6+1].x=a,e[i*6+1].y=c,e[i*6+1].z=b;
			e[i*6+2].x=b,e[i*6+2].y=a,e[i*6+2].z=c;
			e[i*6+3].x=b,e[i*6+3].y=c,e[i*6+3].z=a;
			e[i*6+4].x=c,e[i*6+4].y=a,e[i*6+4].z=b;
			e[i*6+5].x=c,e[i*6+5].y=b,e[i*6+5].z=a;
		} 
		sort(e,e+(n*6));
		int Max=0;
		for(int i=0;i<n*6;i++){ //求最大递增子序列
			dp[i]=e[i].z;
			for(int j=0;j<i;j++){
				if(e[i].x>e[j].x&e[i].y>e[j].y)
					dp[i]=max(dp[i],dp[j]+e[i].z); 
			}
			Max=max(Max,dp[i]);
		}
		printf("Case %d: maximum height = %d\n",++t,Max);
	}
	return 0;
}

Hdu-1074 Doing Homework

第一次写的状压dp题解，请指教！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=16;

int t,n;
struct node{
	int d,c;   //结束时间和所需天数 
	char s[110];
}no[Max_n]; 
int dp[1<<Max_n],time[1<<Max_n],par[1<<Max_n];
//dp[]表示此状态对应扣的分数，time[]表示完成此状态的时刻 ，par[]记录状态转移路径 

void output(int k){ //递归打印路径 
	if(!k)return;
	output(k-(1<<par[k]));
	printf("%s\n",no[par[k]].s);
}

int main()
{
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=0;i<n;i++)scanf("%s%d%d",no[i].s,&no[i].d,&no[i].c);
		memset(time,0,sizeof(time));
		memset(dp,0x3f,sizeof(dp)); //初始化无穷大 
		dp[0]=0;  //dp[000]表示一门课没做，值为0 
		int total=1<<n;
		for(int i=1;i<total;i++){
			for(int j=n-1;j>=0;j--){ //j从大到小判断是否能通过做第j门课达到状态i(例如：状态011可由状态010通过做第1门课得到) 
				int t=1<<j;
				if(!(i&t))continue; //不能通过做第j门课达到
				int s=time[i-t]+no[j].c-no[j].d;  //状态i-t通过做j门课达到状态i所需的代价 
				if(s<0)s=0; //当然不可能为负，最小为0 
				if(dp[i]>dp[i-t]+s){  //更新状态最优解 
					dp[i]=dp[i-t]+s;
					time[i]=time[i-t]+no[j].c;
					par[i]=j; //记录路径，很巧妙，orz~ 
				}
			}
		}
		printf("%d\n",dp[total-1]);
		output(total-1);
	}
	return 0;
}

Hdu-1087 Super Jumping! Jumping! Jumping!

//最大递增子序列 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1100;

int n;
int a[Max_n];
int dp[Max_n];

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

Hdu-1114 Piggy-Bank

//完全背包
//dp[i][j]:表示前i中硬币重量达到j时的最小面值 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=1e4+10;

int t;
int e,f,n,W;
int p[Max_n],w[Max_n];
int dp[Max_n];

int main()
{
	scanf("%d",&t);
	while(t--){
		scanf("%d%d%d",&e,&f,&n);
		W=f-e;
		for(int i=1;i<=n;i++)scanf("%d%d",&p[i],&w[i]);
		memset(dp,0x3f,sizeof(dp));
		dp[0]=0;
		for(int i=1;i<=n;i++){
			for(int j=w[i];j<=W;j++)
			dp[j]=min(dp[j],dp[j-w[i]]+p[i]);
		}
		if(dp[W]!=inf)printf("The minimum amount of money in the piggy-bank is %d.\n",dp[W]);
		else printf("This is impossible.\n");
	}
	return 0;
 }

Hdu-1176 免费馅饼

//dp[i][j]：表示第i秒落在j位置的最大馅饼 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1e5+10;

int n;
struct node{
	int x,t;
	bool operator<(const node& no){
		return t<no.t;
	}
}no[Max_n]; 
int dp[Max_n][22];

int main()
{
	while(~scanf("%d",&n)&&n){
		for(int i=0;i<n;i++){
			scanf("%d%d",&no[i].x,&no[i].t);
			no[i].x++;
		}
		sort(no,no+n);
		memset(dp,-1,sizeof(dp));
		dp[0][6]=0;
		int k=0;
		for(int i=1;i<Max_n;i++){
			for(int j=1;j<=11;j++){
				if(dp[i-1][j-1]!=-1&&dp[i-1][j-1]>dp[i][j])dp[i][j]=dp[i-1][j-1];
				if(dp[i-1][j]!=-1&&dp[i-1][j]>dp[i][j])dp[i][j]=dp[i-1][j];
				if(dp[i-1][j+1]!=-1&&dp[i-1][j+1]>dp[i][j])dp[i][j]=dp[i-1][j+1];
			}
			while(k<n&&no[k].t==i){
				if(dp[i][no[k].x]!=-1)dp[i][no[k].x]++;
				k++;
			}
//			for(int j=1;j<=11;j++)cout<<dp[i][j]<<' ';
//			cout<<endl; 
			if(k==n){
				int Max=0;
				for(int j=1;j<=11;j++)
					if(dp[i][j]>Max)Max=dp[i][j];
				printf("%d\n",Max);
				break;
			}
		}
	}
	return 0;
}

Hdu-1260 Tickets

//dp[i][0]:表示第i个人单独买票的最少时间
//dp[i][1]:表示第i个人和前一个人一起买票的最短时间 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=2e3+10;

int t,n;
int a[Max_n],b[Max_n];
int dp[Max_n][2];

int main()
{
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		for(int i=1;i<=n;i++)scanf("%d",&a[i]);
		for(int i=1;i<=n-1;i++)scanf("%d",&b[i]);
		memset(dp,0x3f,sizeof(dp));
		dp[1][0]=a[1];
		for(int i=2;i<=n;i++){
			dp[i][0]=min(dp[i-1][0],dp[i-1][1])+a[i];
			dp[i][1]=dp[i-1][0]-a[i-1]+b[i-1];
		}
		int ans=min(dp[n][0],dp[n][1]);
		int s,m,h;
		s=ans%60;ans/=60;
		m=ans%60;h=ans/60;
		h=(h+8)%24;
		if(h>12)printf("%02d:%02d:%02d pm\n",h%12,m,s);
		else printf("%02d:%02d:%02d am\n",h,m,s);
	}
	return 0;
}

Hdu-1257 最少拦截系统

//最长上升子序列
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=1e6+10;

int n;
int dp[Max_n];

int main()
{
	while(~scanf("%d",&n)){
		int c;
		memset(dp,0x3f,sizeof(dp));
		for(int i=0;i<n;i++){
			scanf("%d",&c);
			*lower_bound(dp,dp+Max_n,c)=c;
		}
		printf("%d\n",lower_bound(dp,dp+Max_n,inf)-dp); 
	}
	return 0;
}

Hdu-1160 FatMouse’s Speed

//最长下降子序列 （输出没注释导致一直System Error，笨蛋！）
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1e4+10;

struct node{
	int w,s,pos;
	bool operator<(const node& n)const{
		return w<n.w;
	}
}no[Max_n];
int pre[Max_n],dp[Max_n];

void output(int f){ //输出路径 
	if(pre[f]==f){
		printf("%d\n",no[f].pos+1);
		return;
	}
	output(pre[f]);
	printf("%d\n",no[f].pos+1);
}

int main()
{
	int n=0;
	while(~scanf("%d%d",&no[n].w,&no[n].s)){
		no[n].pos=n;
		n++;
	}
	sort(no,no+n);
	dp[0]=1;pre[0]=0;
	int Max=1,f=0;
	for(int i=1;i<n;i++){
		dp[i]=1;pre[i]=i;
		for(int j=0;j<i;j++){
			if(no[j].w!=no[i].w&&no[j].s>no[i].s&&dp[j]+1>dp[i]){
				dp[i]=dp[j]+1;
				pre[i]=j;
			}
		}
		if(dp[i]>Max){
			Max=dp[i];
			f=i;
		}
	}
	printf("%d\n",Max);
	output(f);
	return 0;
}

Poj-1015 Jury Compromise

真的不会写，给跪了~~

Poj-1458 Common Subsequence

//最长公共子序列 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1e3+10;

char s1[Max_n],s2[Max_n];
int dp[Max_n][Max_n];

int main()
{
	while(~scanf("%s%s",s1+1,s2+1)){
		s1[0]=s2[0]='0';
		int len1=strlen(s1),len2=strlen(s2);
		memset(dp,0,sizeof(dp));
		for(int i=1;i<len1;i++){
			for(int j=1;j<len2;j++)
				if(s1[i]==s2[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[len1-1][len2-1]);
	}
	return 0;
}

Poj-1661 Help Jimmy

记第i个平台的左右端点分别l和r，高度为h。
dp[i][j]：表示走到第i个平台的j位置的最少时间，显然j位置只取l和r就好，因为最后要从这两个位置下来的。
再看，dp[i][l]和dp[i][r]不仅和前一个平台有关，和它之前的平台都有关，因为可以一下跳过几个平台的。
再吧啦吧啦其中的关系，找找递推关系就好了。
最后，dp[j]：表示在j位置的最少时间，h[j]：表示在j位置的高度。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=1e4+10;

int t,n,x,y,f;
struct node{
	int x,y,h;
	bool operator<(const node& no)const {
		return h>no.h;
	}
}no[Max_n];
int mid=20000; //有负数 整体右移mid 
int dp[4*Max_n],h[4*Max_n];

int main()
{
	scanf("%d",&t);
	while(t--){
		scanf("%d%d%d%d",&n,&x,&y,&f);
		int ans=0,a,b,c;
		for(int i=0;i<n;i++){
			scanf("%d%d%d",&a,&b,&c);
			if(c<=y){ //保留高度<=y的平台 
				no[ans].x=a+mid;no[ans].y=b+mid;
				no[ans++].h=c;
			}
		}
		x+=mid;
		no[ans].x=x;no[ans].y=x;no[ans].h=y; //起始平台长度为0（即左右端点重合,都为x）高度为y 

		sort(no,no+ans+1);
		memset(dp,0x3f,sizeof(dp));
		memset(h,0x3f,sizeof(h));
		dp[x]=0;h[x]=y;

		for(int i=1;i<=ans;i++){ //状态转移 
			int l=inf,r=inf;
			for(int j=no[i].x;j<=no[i].y;j++){
				if(dp[j]!=inf&&h[j]-no[i].h<=f){
					l=min(l,dp[j]+h[j]-no[i].h+j-no[i].x);
					r=min(r,dp[j]+h[j]-no[i].h+no[i].y-j);
				}
			}
			for(int j=no[i].x;j<=no[i].y;j++)dp[j]=h[j]=inf;
			if(l!=inf){
				dp[no[i].x]=l;
				dp[no[i].y]=r;
				h[no[i].x]=h[no[i].y]=no[i].h;
			}
		}
		int Min=inf;
		for(int i=0;i<=2*mid;i++){
			if(h[i]<=f)Min=min(Min,dp[i]+h[i]);
		}
		printf("%d\n",Min);

	}
	return 0;
}

Poj-2533 Longst Ordered Subsequence

//最长递增子序列
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=1e6+10;

int n;
int dp[Max_n];

int main()
{
	scanf("%d\n",&n);
	int c;
	memset(dp,0x3f,sizeof(dp));
	for(int i=0;i<n;i++){
		scanf("%d",&c);
		*lower_bound(dp,dp+n,c)=c;
	}
	printf("%d\n",lower_bound(dp,dp+n,inf)-dp);
	return 0;
}

Poj-3186 Treats For the Cows

//区间dp（类似数塔取数）
//dp[i][j]：表示当前可取第i个元素或第j个元素得到的最大值 
#include<iostream>
#include<cstdio>
#include<cstring> 
#include<algorithm>
using namespace std;
const int Max_n=2200;

int n;
int a[Max_n];
int dp[Max_n][Max_n];

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	for(int i=1;i<=n;i++)
		dp[i][i]=a[i]*n;
	for(int k=1;k<n;k++){ //用k记录第几次取 
		for(int i=1;i+k<=n;i++){
			int j=i+k;
			dp[i][j]=max(dp[i][j-1]+a[j]*(n-k),dp[i+1][j]+a[i]*(n-k));
		}
	}
	printf("%d\n",dp[1][n]); 
	return 0;
}

Hdu-1078 FatMouse and Cheese

//dp求解技巧--记忆化搜索
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=110;

int n,k;
int a[Max_n][Max_n],dp[Max_n][Max_n];
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};

int dfs(int x,int y){
	if(dp[x][y])return dp[x][y];
	int X,Y;
	for(int i=0;i<4;i++){
		for(int j=1;j<=k;j++){
			X=x+dx[i]*j;
			Y=y+dy[i]*j;
			if(X>=0&&X<n&&Y>=0&&Y<n&&a[X][Y]>a[x][y]){
				dp[x][y]=max(dp[x][y],dfs(X,Y)+a[X][Y]);
			}
		}
	}
	return dp[x][y];
}

int main()
{
	while(~scanf("%d%d",&n,&k)&&n!=-1){
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++)
				scanf("%d",&a[i][j]);
		}
		memset(dp,0,sizeof(dp));
		printf("%d\n",dfs(0,0)+a[0][0]);
	}
	
	return 0;
}

Hdu-2859 Phalanx}

一开始理解错题意，可过了样例，WA，然后百度题解，明白了，出现bug,可又过了样例，WA，写了一下午加小半晚上，很水的一个题，撑死半小时AC，最近心态不好了，淡定，淡定，淡定，加油，加油，加油！！！

// dp[i][j]：表示左下角坐标为(x,y)的最大方阵大小 
// dp[i][j]由dp[i-1][j+1]推导出来 
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1100;

int n;
char s[Max_n][Max_n];
int dp[Max_n][Max_n];

int main()
{
	while(~scanf("%d",&n)&&n){
		for(int i=1;i<=n;i++)
			scanf("%s",s[i]+1);
		memset(dp,0,sizeof(dp));
		int Max=1;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=n;j++){
				if(i==1||j==n){ //初始化边界 
					dp[i][j]=1;
					continue;
				}
				int x=i,y=j;
				while(x>=1&&y<=n&&s[x][j]==s[i][y]){
					x--;y++;
				}
				dp[i][j]=min(dp[i-1][j+1]+1,i-x);
				Max=max(dp[i][j],Max);
			}
		}
		printf("%d\n",Max);
	}
	return 0;
}

Poj-3616 Milking Time

// 最大递增子序列
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int Max_n=1e6+10;
const int Max_m=1e3+10;

int n,m,r;
struct edge{
	int s,t,e;
	bool operator<(const edge&e)const {
		return t<e.t;
	}
}e[Max_m];
int dp[Max_n];

int main()
{
	scanf("%d%d%d",&n,&m,&r);
	memset(dp,0,sizeof(dp));
	for(int i=0;i<m;i++)
		scanf("%d%d%d",&e[i].s,&e[i].t,&e[i].e);
	sort(e,e+m);
	int ans=0;
	for(int i=0;i<m;i++){
		dp[i]=e[i].e;
		for(int j=0;j<i;j++){
			if(e[i].s>=e[j].t+r&&dp[i]<dp[j]+e[i].e)
			dp[i]=dp[j]+e[i].e;
		}
		ans=max(ans,dp[i]);
	}
	printf("%d\n",ans);
	return 0;
}

Poj-3666 Making the Grade

首先我们会发现，最终修改后，或者和前一个数字一样，或者和后一个数字一样，这样才能修改量最小。
我们先根据原数列排序，确定元素的大小关系，对应编号为p[i]。
dp[i][j]：表示考虑前i个元素，最后元素s[i]为序列中第j小元素的最小成本。
dp[i][j] = min(dp[i-1][k]) + abs(s[i]-p[j]), (1<=k<=j) // 非严格递增

#include<iostream>
#include<cstdio>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
const int Max_n=2200;

int n;
int s[Max_n],p[Max_n];
int dp[Max_n][Max_n]; //表示考虑前i个元素，最后元素序列中第j小元素的最小成本

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&s[i]);
        p[i]=s[i];
    }
    sort(p+1,p+n+1);
    for(int i=1;i<=n;i++)
        dp[1][i]=abs(s[1]-p[i]);
    for(int i=2;i<=n;i++){
        int t=dp[i-1][1];
        for(int j=1;j<=n;j++){
            t=min(dp[i-1][j],t);
            dp[i][j]=t+abs(s[i]-p[j]);
        }   
    }

    int Min=inf;
    for(int i=1;i<=n;i++)
        Min=min(Min,dp[n][i]);
    printf("%d\n",Min);

    return 0;   
}

zzti_xiaowei

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
[kuangbin带你飞]专题十二基础DP1

Hdu-1024 Max Sum Plus PlusHdu-1029 Ignatius and the Princess IV// 简单桶排序，dp[i]记录数字i出现的次数#include&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt
复制链接

扫一扫