- 经典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;
}
// 先求出每个积木的六种摆放方式,然后排序后求最大递增子序列。
// 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;
}
- 第一次写的状压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;
}
//完全背包
//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;
}
//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;
}
//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;
}
//最长上升子序列
#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;
}
//最长下降子序列 (输出没注释导致一直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;
}
- 真的不会写,给跪了~~
//最长公共子序列
#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;
}
- 记第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;
}
//区间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;
}
//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;
}
- 一开始理解错题意,可过了样例,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;
}
// 最大递增子序列
#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;
}
- 首先我们会发现,最终修改后,或者和前一个数字一样,或者和后一个数字一样,这样才能修改量最小。
- 我们先根据原数列排序,确定元素的大小关系,对应编号为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;
}