HDU （dp） 2955 1864 1231 1506 1505 2602 1087 2571 1069

最新推荐文章于 2019-05-16 16:01:34 发布
最新推荐文章于 2019-05-16 16:01:34 发布
阅读量140 收藏
点赞数
分类专栏： 动态规划 hdu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41453511/article/details/86527300
版权

http://acm.hdu.edu.cn/showproblem.php?pid=2955

  dp[j]=max(dp[i],dp[j-ac[i].M]*(1-ac[i].P));

#include<iostream>
#include<algorithm>
#include<string.h>
#include<math.h>
using namespace std;
struct node{
	double P;
	int M;
}ac[15000];
double dp[12000];
int main(){
	int n;
	scanf("%d",&n);
	while(n--){
		double x;
		int  m;
		int sum=0;
		scanf("%lf%d",&x,&m);
		for(int i=0;i<m;i++){
			scanf("%d%lf",&ac[i].M,&ac[i].P);
			sum+=ac[i].M; 
		}
		memset(dp,0,sizeof(dp));
		dp[0]=1;
		for(int i=0;i<m;i++){
			for(int j=sum;j>=ac[i].M;j--){
				dp[j]=max(dp[j],dp[j-ac[i].M]*(1.0-ac[i].P));
			}
		}
		for(int i=sum;i>=0;i--){
			if(dp[i]>1.0-x){
				printf("%d\n",i);
				break;
			} 
		}
	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=1864

状态方程     dp[j]=max(dp[j],dp[j-num[i]]+num[i])    输入emmm

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int num[120];
int dp[3000000];
int main(){
    double q,price;
    int sum,sum1;
    int n,i,j,m,flag,cnt,p,b,c,v;
    char tp;
    while(scanf("%lf%d",&q,&n)!=EOF&&n){
        memset(dp,0,sizeof(dp));
        sum=(int)(q*100);
        cnt=0;
        for (i=0;i<n;i++){   
            num[i]=0;
            scanf("%d",&m);
            flag=1;
            sum1=0;
            p=b=c=0;
            while(m--){
                scanf(" %c:%lf",&tp,&price);
                v=(int)(price*100);
                if(tp=='A')
                    p+=v;
                else if(tp=='B')
                    b+=v;
                else if(tp=='C')
                    c+=v;
                else flag=0;
            }
            if(flag&&p<=60000&&b<=60000&&c<=60000&&p+b+c<=100000){
                num[cnt++]=p+b+c; 
            }
        }
        for (i=0;i<cnt;i++){
            for (j=sum;j>=num[i];j--){
                dp[j]=max(dp[j],dp[j-num[i]]+num[i]);
            }
        }
        printf("%.2lf\n", dp[sum]/100.0);
    }
    return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=1231 最长子串和  //dp[i]=max(dp[i-1]+a[i],a[i]) 状态方程 记录开始位置和最后位置时当dp[i]==a[i]时开始，然后都为负数时才会出现没有和大于0

#include<iostream>
#include<bits/stdc++.h>
#define maxn 10000
using namespace std;
int a[maxn];
int sum[maxn];
int dp[maxn<<1];
int main(){
	int n;
	while(scanf("%d",&n)&&n!=0){
		memset(a,0,sizeof(a));
		int maxx=-1,k=0,s1,e1,s2,e2;
		for(int i=1;i<=n;i++){
			cin>>a[i];
		}
		for(int i=1;i<=n;i++){
			dp[i]=max(dp[i-1]+a[i],a[i]);
			if(a[i]<0)
			k++;
			if(dp[i]==a[i]){
				s1=i;
				e1=i;
			}else{
				e1=i;
			}
			if(dp[i]>maxx){
				maxx=dp[i];
				s2=s1;
				e2=e1;
			}
		}
		if(n==k)
		printf("0 %d %d\n",a[1],a[k]);
		else
		printf("%d %d %d\n",maxx,a[s2],a[e2]);

	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=1506 height[i]*(r[i]-l[i]+1) 为最大值  现在只需要判断每个长方形的最长延伸点，让他向两边延伸只要它左边比他高就可以向左，右边比他高就可以向右，然后用他本身的高度乘上长度

#include<iostream>
#define maxn 100005
#define ll long long
using namespace std;
ll a[maxn];
ll r[maxn];
ll l[maxn];
int main(){
	int n;
	while(scanf("%d",&n)&&n!=0){
		for(int i=1;i<=n;i++){
			scanf("%lld",&a[i]);
			r[i]=l[i]=i;
		}
		a[0]=-1,a[n+1]=-1;
		for(int i=1;i<=n;i++){
			while(a[l[i]-1]>=a[i]){
				l[i]=l[l[i]-1];
			}
		}
		for(int i=n;i>=1;i--){
			while(a[r[i]+1]>=a[i]){
				r[i]=r[r[i]+1];
			}
		}
		ll ans=0,temp;
		for(int i=1;i<=n;i++){
			temp=a[i]*(r[i]-l[i]+1);
			ans=max(temp,ans);
		}
		cout<<ans<<endl;
	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=1505  处理数组的时候有点问题，直接预处理行，然后就和上面一样

#include<iostream>
#include<bits/stdc++.h>
#define maxn 1200
#define ll long long
using namespace std;
int map1[maxn][maxn];
int r[maxn],l[maxn];
int main(){
	int t,n,m;
	cin>>t;
	while(t--){
		int ans=-1;
		memset(map1,0,sizeof(map1));
		memset(r,0,sizeof(r));
		memset(l,0,sizeof(l));
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
					char x;
				cin>>x;
				if(x=='F'){
					map1[i][j]=map1[i-1][j]+1;
				}else{
					map1[i][j]=0;
				}
			}
		}
		for(int i=1;i<=n;i++){
			l[1]=1;
			r[m]=m;
			map1[i][0]=map1[i][m+1]=-1;
			for(int j=2;j<=m;j++){
				l[j]=j;
				while(map1[i][j]<=map1[i][l[j]-1]){
					l[j]=l[l[j]-1];
				}
			}
			for(int j=m-1;j>=1;j--){
				r[j]=j;
				while(map1[i][r[j]+1]>=map1[i][j]){
					r[j]=r[r[j]+1];
				}
			}
			for(int j=1;j<=m;j++){
				ans=max(ans,map1[i][j]*(r[j]-l[j]+1));
			}
		}
		cout<<ans*3<<endl;
	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=2602 01背包

#include<iostream>
#include<bits/stdc++.h>
#define maxn 1200
using namespace std;
int w[maxn],v[maxn];
int dp[maxn];
int main(){
	int t,num,weight;
	cin>>t;
	while(t--){
		cin>>num>>weight;
		for(int i=1;i<=num;i++){
			cin>>v[i];
		}
		for(int i=1;i<=num;i++){
			cin>>w[i];
		}
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=num;i++){
			for(int j=weight;j>=w[i];j--){
				dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
			}
		}
		cout<<dp[weight]<<endl;
	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=1087    最长上升子序列

#include<iostream>
#include<bits/stdc++.h>
#define maxn 1200
using namespace std;
int a[maxn];
int dp[maxn];
int main(){
	int n;
	while(scanf("%d",&n)&&n!=0){
		memset(a,0,sizeof(a));
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=n;i++){
			cin>>a[i];
		}
		int maxx=-1;
		dp[0]=0;
		a[0]=0;
		for(int i=1;i<=n;i++){
			for(int j=0;j<i;j++){
				if(a[i]>a[j]){
					dp[i]=max(dp[i],dp[j]+a[i]);
				}
			}
			dp[i]=max(dp[i],a[i]);
			maxx=max(maxx,dp[i]);
		}
		cout<<maxx<<endl;
	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=2571  //dp[i][j]=max(dp[i-1][j],dp[i][j-1])    dp[i][j]=max(dp[i][j],dp[i][j/k])

#include<iostream>
#include<bits/stdc++.h>
#define maxn 1200
#define inf -0x3f3f3f
#define clear(a,b) memset(a,b,sizeof(a))
using namespace std;
int map1[maxn][maxn];
int dp[maxn][maxn];
int main(){
	int t;
	cin>>t;
	while(t--){
		clear(map1,0);
		clear(dp,0);
		int n,m;
		cin>>n>>m;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				cin>>map1[i][j];
			}
		}
		for(int i=0;i<=n;i++){
			dp[i][0]=-999999;
		}
		for(int i=0;i<=m;i++){
			dp[0][i]=-999999;
		}
		dp[1][0]=dp[0][1]=0;
		for(int i=1;i<=n;i++){
			for(int j=1;j<=m;j++){
				dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
				for(int k=2;k<=j;k++){
					if(j%k==0){
						dp[i][j]=max(dp[i][j],dp[i][j/k]);
					}
				}
				dp[i][j]+=map1[i][j];
			}
		}
		cout<<dp[n][m]<<endl;
	}
	return 0;
}

http://acm.hdu.edu.cn/showproblem.php?pid=1069  k++最后没有卡了好久....最大下降序列

#include<iostream>
#include<bits/stdc++.h>
#define maxn 200
using namespace std;
struct node{
	int x;
	int y;
	int z;
}ac[maxn];
bool cmp(node a,node b){
	if(a.x==b.x)
	return a.y>b.y;
	return a.x>b.x;
}
int dp[maxn];
int main(){
	int n;
	int q=0;
	while(scanf("%d",&n)&&n!=0){
		int ans=0;
		memset(dp,0,sizeof(dp));
		memset(ac,0,sizeof(ac));
		int k=1;
		for(int i=0;i<n;i++){
			int X,Y,Z;
			cin>>X>>Y>>Z;
			ac[k].x=X,ac[k].y=Y,ac[k].z=Z;
			k++;
			ac[k].x=X,ac[k].y=Z,ac[k].z=Y;
			k++;
			ac[k].x=Y,ac[k].y=X,ac[k].z=Z;
			k++;
			ac[k].x=Y,ac[k].y=Z,ac[k].z=X;
			k++;
			ac[k].x=Z,ac[k].y=X,ac[k].z=Y;
			k++;
			ac[k].x=Z,ac[k].y=Y,ac[k].z=X;
			k++;
		}
		sort(ac+1,ac+k+1,cmp);
		for(int i=1;i<=k;i++){
			dp[i]=ac[i].z;
			for(int j=1;j<i;j++){
				if(ac[i].x<ac[j].x&&ac[i].y<ac[j].y){
					dp[i]=max(dp[i],dp[j]+ac[i].z);
				}
			}
			ans=max(ans,dp[i]);
		}
		cout<<"Case "<<++q<<": maximum height = "<<ans<<endl;
	}
	return 0;
}

 

abns
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 1087
~
08-17 735
Nowadays, a kind of chess game called “Super Jumping! Jumping! Jumping!” is very popular in HDU. Maybe you are a good boy, and know little about this game, so I introduce it to you now.  The game ...
HDU DP 题集
04-24
动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，...
HDU 1506 && HDU1505 && HDU 2870 （DP）.
ACM之路，在希望的田野上。
08-01 980
~~~~ 这三道DP题是逐层递进的，大家可以从前往后做。 题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1506 http://acm.hdu.edu.cn/showproblem.php?pid=1505    http://acm.hdu.edu.cn/showproblem.php?pid=2870 ~~~~ 1506： 分别找每
hdu2602 dp 01背包
671coder的专栏
04-01 3520
链接：点我 很简单的01，注意第一排输入的是价值，第二排是体积。。 #include #include using namespace std; #define max(a,b) ((a)>(b)?(a):(b)) const int maxn = 1005; int main() { int T; scanf("%d", &T); int dp[maxn], val[maxn]
hdu2955 Robberies 01背包 dp
671coder的专栏
04-01 4121
链接：点我 题意：一个强盗要去抢劫银行，对于每个银行来说，都有一个不被抓的概率p，和能抢劫到的钱数money,每个银行最多只可以被抢劫一次。问在不被抓的总概率P下，怎样得到最大价值的钱数。 分析：我第一眼看的时候觉得见到01，然后弄一个dp[100]，把概率*100。。。。。。如果你和我一样这么想。。那么恭喜你上当了！需要把money当做下标。。。保存的是概率。。。状态转移方程：dp[j] =
hdu1506 1505 2870最大子矩形 DP
hccz95的专栏
08-02 973
Largest Rectangle in a Histogram
HDU 1087--DP--（水）
关于学习本身
05-27 1238
题意：有一数轴，中间有n个具有不用权值的点可以走，每一步只能从权值低的跳到权值高的点，求从起点走到终点能收集到的最大的权值。 分析：基础的dp.  dp[i]代表走到i点时收集到的最大权值。状态转移方程：dp[i]=max(dp[j]+a[i],dp[i])  其中 j 代码： #include using namespace std; int n,a[1001]; long long dp
hdu dp60题
nktif
09-07 450
准备顺序推掉杭电dp60题不管怎样立个flag23333啊喂不管怎样第一题都没有吗2333那就杭电dp59题好了2333 2017-09-04 : hdu 1011 Starship Troopers 树形dp 2017-09-06 : hdu 1024 Max Sum Plus Plus 最大m个子序列 2017-09-07 : hdu 1025 Constr
HDU 2955-Robberies（01背包变形）
Some.
05-14 1006
Robberies Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 19371    Accepted Submission(s): 7149 Problem Description The aspiring Roy th
hdu2602 Bone Collector(背包问题)
苏苏爱自由
08-12 1991
Bone Collector Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 39612    Accepted Submission(s): 16412 Problem Description Many year
HDU 1069 Monkey and Banana（最大的单调递减序列 dp）
07-16 1349
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1069 Problem Description A group of researchers are designing an experiment to test the IQ of a monkey. They will hang a banana at the roof of a ...
DP.rar_DP_hdu_动态规划_动态规划 C++
最新发布
09-20
标题中的“DP.rar”表明这是一个关于动态规划的资料压缩包，而“DP_hdu”暗示了这些题目可能来自杭州电子科技大学（HDU）的在线编程平台。动态规划通常用于解决那些可以通过子问题的最优解来构建原问题最优解的问题...
HDU DP题解
02-07
HDU上DP大集合，里面包括题，题解，代码，对DP入门者很实用，对DP老手也是有很大的提高
HDU DP动态规划
03-31
【标题】"HDU DP动态规划"涉及到的是在算法领域中的动态规划（Dynamic Programming，简称DP）技术，这是解决复杂问题的一种高效方法，尤其适用于有重叠子问题和最优子结构的问题。动态规划通常用于优化多阶段决策...
acmhdu1005
04-17
hdu 1005.比较简单的一道题，有兴趣的可以看看。
模拟退火（最小球覆盖，最小圆覆盖）
abns的博客
05-16 710
#include <iostream> #include <string.h> #include <stdio.h> #include <math.h> #define N 150 #define eps 1e-8 #define T 100 #define delta 0.98 #define INF 1e99 using namespa...
HDU 3763 CD
abns的博客
08-15 319
Jack and Jill have decided to sell some of their Compact Discs, while they still have some value. They have decided to sell one of each of the CD titles that they both own. How many CDs can Jack and J...
hdu 2544最短路(dijkstra+链式前向星）
abns的博客
12-23 314
http://acm.hdu.edu.cn/showproblem.php?pid=2544   Problem Description 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？       Input 输入包括多组...
hdu2647（链式前向星+拓扑排序）Reward
abns的博客
12-23 298
http://acm.hdu.edu.cn/showproblem.php?pid=2647 Dandelion's uncle is a boss of a factory. As the spring festival is coming , he wants to distribute rewards to his workers. Now he has a trouble about h...
动态规划：LIS模型及应用实战——从HDU1069到PKU1936
在计算机科学特别是算法设计中，两个常见的问题涉及到这种模型的是HDU1069（http://acm.hdu.edu.cn/showproblem.php?pid=1069）和HDU1160（http://acm.hdu.edu.cn/showproblem.php?pid=1160）。这里提到的LCS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值