HDU 1024
第一遍水过，没有体会到这个题的奥妙，思考了很久终于体会了。
大概意思是求把序列分成m段的子序列，并不一定要覆盖完，求子序列和的最大值
我们首先要写出基本的动态转移方程：
DP:dp[ i ] [ j ] =max ( dp[ i - 1 ] [ 1~j-1 ]+a[ j ],dp[ i ] [ j - 1 ]+a[ j ] )
其中dp[ i ][ j ]其中i,j表示,第i个集合，取前j 个数。
意思是，dp[ i ][ j ]是由两个状态转移过来的，一个是把新的数归入i集合，还有一个是把新的数作为第一
个数，归入新的集合。但是显然这个DP方程显得过于臃肿，我们想办法化简一下，我们发现，每次dp[i][j]
都只和dp[i][j-1]以及dp[i-1][1~j-1]中的最大值有关，因此我们不妨把dp化简,用两个数组表示，now[j]数组表
示当前a[j]在子序列中的最优值。pre[j]代表在上个序列中序列j最大值，在结合程序，也就比较好相通了。
相当于now维护dp[ i ] [ j ]，而pre[j]维护的是dp[i-1][j] 。
#include<iostream> #include<algorithm> #include<stdio.h> #include<string.h> using namespace std; const int maxn = 1e6+7; const int INF = 0x3f3f3f3f; int now[maxn]; int a[maxn]; int pre[maxn]; int main(){ int m,n; while(~scanf("%d%d",&m,&n)){ for (int i=1;i<=n;i++){ scanf("%d",&a[i]); } int maxx; memset(now,0,sizeof(now)); memset(pre,0,sizeof(pre)); for (int i=1;i<=m;i++){ maxx=-INF; for (int j=i;j<=n;j++){ now[j]=max(now[j-1]+a[j],pre[j-1]+a[j]); pre[j-1]=maxx; if(now[j]>maxx)maxx=now[j]; } } printf("%d\n",maxx); } return 0; }
还做到一个很类似的题目：
把一段序列分成多个段，每个段最多k个，用每段的最大值替换每段里面的所有值。
其实也是一个DP:
maxx代表i-j内最大值，dp[j]=(dp[i-1]+maxx*(j-i+1),dp[j])
这样就非常简单的了，我们想想为什么，因为首先我们要确定一定要维护一个区间的最大值，因此也要
枚举区间，然后很容易写出转移方程。
B-不说了。。。
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; const int maxx = 1e6+7; int a[maxx]; int n; int main(){ while(~scanf("%d",&n)){ for (int i=1;i<=n;i++){ scanf("%d",&a[i]); } sort(a+1,a+1+n); int ans=0; int last=a[1]; int cnt=0; for (int i=1;i<=n;i++){ if (last==a[i]){ cnt++; }else { last=a[i]; cnt=1; } if (ans<cnt){ ans=a[i]; } } printf("%d\n",ans); } return 0; }
C-最长递增子序列问题翻版
之间把所有可能的情况加入，按照X坐标排序后，写出限制条件，求最长的可能。
dp[i]=max(dp[i],dp[j]+1) 其中j<i
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; struct node{ int x,y,z; }a[200]; int tot; void join(int x,int y,int z){ a[++tot].x=x; a[tot].y=y; a[tot].z=z; } bool cmp(node a,node b){ return a.x<b.x; } int dp[80]; int main(){ int n; int cas=1; while(~scanf("%d",&n)){ if (n==0)break; int tmp[5]; tot=0; memset(a,0,sizeof(a)); for (int i=1;i<=n;i++){ scanf("%d%d%d",&tmp[1],&tmp[2],&tmp[3]); join(tmp[1],tmp[2],tmp[3]); join(tmp[1],tmp[3],tmp[2]); join(tmp[2],tmp[1],tmp[3]); join(tmp[2],tmp[3],tmp[1]); join(tmp[3],tmp[1],tmp[2]); join(tmp[3],tmp[2],tmp[1]); } dp[0]=0; sort(a+1,a+1+tot,cmp); for (int i=1;i<=tot;i++){ dp[i]=a[i].z; for (int j=i-1;j>=1;j--){ if (a[j].x<a[i].x && a[j].y<a[i].y){ dp[i]=max(dp[i],dp[j]+a[i].z); } } } int ans=0; for (int i=1;i<=tot;i++){ ans=max(ans,dp[i]); } printf("Case %d: maximum height = %d\n",cas++,ans); } return 0; }
D-经典的时间分配问题
状压DP
n种物品，枚举每一位的情况，用1-1<<n-1表示每一位是否存在，然后计算得分，然后维护dp[]最小，同时
保存路径，由于是求字典序最小，我们需要把枚举顺序反向，然后最后反向输出结果即可，因为我们记录的
是当前情况之前的情况，因此我们需要从最终情况开始往前找，找到前面即可，
#include<iostream> #include<algorithm> #include<string.h> #include<stdio.h> using namespace std; const int maxx = 1<<15; const int INF = 0x3f3f3f3f; char name[20][120]; int die[20]; int fin[20]; int dp[maxx];//到达当前状态所需要的最小得分 int t[maxx];//做作业所需要花的时间 int pre[maxx];//到达某个状态所需要完成的课程 void output(int x){ if (!x)return; output(x-(1<<pre[x])); printf("%s\n",name[pre[x]]); } int main(){ int ca; scanf("%d",&ca); int n; while(ca--){ scanf("%d",&n); memset(t,0,sizeof(t)); int bit=1<<n; for (int i=0;i<n;i++){ scanf("%s%d%d",name[i],&die[i],&fin[i]); } for (int i=1;i<bit;i++){ dp[i]=INF; for (int j=n-1;j>=0;j--){ int temp=1<<j;//第j位的情况 if((i&temp)==0)continue;//这一位没有被选到 int score=t[i-temp]+fin[j]-die[j]; if (score<0)score=0; if (dp[i]>dp[i-temp]+score){//把分最小化 dp[i]=dp[i-temp]+score;//更新为更小的 t[i]=t[i-temp]+fin[j];//达到状态t[i]所花的时间 pre[i]=j;//到达状态i的前驱 } } } printf("%d\n",dp[bit-1]); output(bit-1); } return 0; }
E Super Jumping! Jumping! Jumping!
翻版最长递增子序列
#include<iostream> #include<stdio.h> #include<algorithm> #include<string.h> #define LL long long using namespace std; int a[1008]; LL dp[1008]; int main(){ int n; while(~scanf("%d",&n) && n){ for(int i=1;i<=n;i++){ scanf("%d",&a[i]); } memset(dp,0,sizeof(dp)); for (int i=1;i<=n;i++){ dp[i]=a[i]; for (int j=i-1;j>=1;j--){ if (a[i]>a[j]) dp[i]=max(dp[i],dp[j]+a[i]); } } LL ans=0; for (int i=1;i<=n;i++){ ans=max(ans,dp[i]); } printf("%lld\n",ans); } return 0; }
F HDU - 1114
完全背包+背包装满
由于是求最小值，初始化为边界值，然后判断是否仍是边界值，从而判断是否装满，
对于每个物品，枚举每个状态，并顺序枚举，这样每个状态可能用多次，从而达到完全背包的效果，反之
01背包则不行，必须反向枚举，每个状态都只能由一个状态构成。
#include<iostream> #include<algorithm> #include<stdio.h> #include<string.h> using namespace std; int dp[10005]; int p[505]; int w[505]; const int INF = 0x3f3f3f3f; int main(){ int t; int E,F; scanf("%d",&t); while(t--){ scanf("%d%d",&E,&F); int W=F-E; int n; scanf("%d",&n); memset(dp,0,sizeof(dp)); for (int i=1;i<=n;i++){ scanf("%d%d",&p[i],&w[i]); } for(int i=1;i<=W;i++){ dp[i]=INF; } for (int i=1;i<=n;i++){ for (int j=w[i];j<=W;j++){ dp[j]=min(dp[j-w[i]]+p[i],dp[j]); } } if (dp[W]==INF){ printf("This is impossible.\n"); }else { printf("The minimum amount of money in the piggy-bank is %d.\n",dp[W]); } } return 0; }
G HDU - 1176
数塔问题，从低到高反向求解
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; int a[100015][12]; int dp[100015][12]; int main(){ int n; while(scanf("%d",&n)!=EOF && n){ int tmp1,tmp2; int t=0; memset(a,0,sizeof(a)); memset(dp,0,sizeof(dp)); for (int i=1;i<=n;i++){ scanf("%d%d",&tmp1,&tmp2); a[tmp2][tmp1]++; t=max(tmp2,t); } for (int i=0;i<=10;i++){ dp[t][i]=a[t][i]; } for (int i=t-1;i>=0;i--){ for (int j=0;j<=10;j++){ if (j==0) dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+a[i][j]; else dp[i][j]=max(dp[i+1][j],max(dp[i+1][j-1],dp[i+1][j+1]))+a[i][j]; } } printf("%d\n",dp[0][5]); } return 0; }
H- HDU 1260
简单DP，给出买一张，买相邻两张的价格，可以选择买一张或者买两张相邻的。
转移方程
dp[i]=max(dp[i-1]+one[i],dp[i-2]+two[i-1])
#include<iostream> #include<string.h> #include<algorithm> #include<stdio.h> using namespace std; int dp[2022]; int one[2022]; int two[2022]; const int INF = 0x3f3f3f3f; int main(){ int t; int n; scanf("%d",&t); while(t--){ scanf("%d",&n); for (int i=1;i<=n;i++){ scanf("%d",&one[i]); } for (int i=1;i<=n-1;i++){ scanf("%d",&two[i]); } dp[1]=one[1]; for (int i=2;i<=n;i++){ dp[i]=min(dp[i-1]+one[i],dp[i-2]+two[i-1]); } int a=dp[n]/3600+8; int b=(dp[n]/60)%60; int c=dp[n]%60; if(a>12||(a==12&&(b>0||c>0))) printf("%.2d:%.2d:%.2d pm\n",a,b,c); else printf("%.2d:%.2d:%.2d am\n",a,b,c); } return 0; }
I-HDU 1257
需要递减覆盖数目=最长递增子序列个数，因为没最长的递增子序列中的每个数，一定能把所有递减的序列
给覆盖掉。
#include<iostream> #include<string.h> #include<algorithm> #include<stdio.h> using namespace std; int dp[10005]; int h[10005]; int main(){ int n; while(~scanf("%d",&n)){ for (int i=1;i<=n;i++){ scanf("%d",&h[i]); } for (int i=1;i<=n;i++){ dp[i]=1; for (int j=1;j<i;j++){ if (h[i]>h[j]){ dp[i]=max(dp[i],dp[j]+1); } } } int ans=0; for (int i=1;i<=n;i++){ ans=max(ans,dp[i]); } printf("%d\n",ans); } return 0; }
J-HDU - 1160
排序+最长递增子序列问题
#include<iostream> #include<string.h> #include<algorithm> #include<stdio.h> #include<stack> using namespace std; const int maxx = 1005; struct node { int w,s,id; } a[maxx]; bool cmp1(node a,node b) { return a.w<b.w; } int dp[1005]; int pre[1005]; int ans[1005]; int main() { int n=1; while(~scanf("%d%d",&a[n].w,&a[n].s)) { a[n].id=n; n++; } memset(pre,-1,sizeof(pre)); memset(dp,0,sizeof(dp)); sort(a+1,a+n,cmp1); for (int i=1; i<n; i++) { dp[i]=1; for (int j=1; j<i; j++) { if (a[j].w<a[i].w && a[j].s>a[i].s){ if (dp[i]<dp[j]+1){ dp[i]=dp[j]+1; pre[i]=j; } } } } // for (int i=1;i<n;i++){ // cout<<a[i].w<<" "<<a[i].id<<endl; // } int maxx=0; int max_id; for (int i=1; i<n; i++) { if (maxx<dp[i]) { maxx=dp[i];// max_id=i;//记录下最后面的那个的位置 } } int p=max_id; printf("%d\n",maxx); int cnt=1; while(p!=-1) { ans[cnt++]=a[p].id; //printf("%d\n",a[p].id); p=pre[p]; } for (int i=cnt-1;i>=1;i--){ printf("%d\n",ans[i]); } return 0; }
L-POJ - 1458
最长公共序列问题
用dp[i][j]表示，匹配到第i位和第j位时的最长递增公共序列的情况，
转移方程
第i位和第j位不匹配时
dp[i][j]=max(dp[i-1][j]),dp[i][j-1])
匹配时
dp[i][j]=dp[i-1][j-1]+1;
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; char a[10005]; char b[10005]; int dp[1005][1005]; int main(){ while(~scanf("%s%s",&a,&b)){ memset(dp,0,sizeof(dp)); int n=strlen(a); int m=strlen(b); for (int i=1;i<=n;i++){ for (int j=1;j<=m;j++){ if (a[i-1]==b[j-1]){ 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[n][m]); } return 0; }
M-POJ - 1661
高级版本数塔+排序
dp[i][0]表示跑到第i层的左边，left表示下面层数的左边跑上来，right是表示下面层的右边跑上来
dp[i][1]表示跑到第i层的右边
dp[i][0]=min(dp[left][0]+a[i].l-a[left].l,dp[left][1]+a[left].r-a[i].l);
dp[i][1]=min(dp[right][0]+a[i].r-a[right].l,dp[right][1]+a[right].r-a[i].r);
#include<iostream> #include<string.h> #include<algorithm> #include<stdio.h> #define LL long long using namespace std; struct node { int l,r,h; } a[1005]; bool cmp(node a,node b) { return a.h<b.h; } int dp[1005][3]; int main() { int t; scanf("%d",&t); int n,x,y,maxx; while(t--) { scanf("%d%d%d%d",&n,&x,&y,&maxx); a[0].l=x; a[0].r=x; a[0].h=y; memset(dp,0,sizeof(dp)); for (int i=1; i<=n; i++) { scanf("%d%d%d",&a[i].l,&a[i].r,&a[i].h); dp[i][0]=0x3f3f3f3f; dp[i][1]=0x3f3f3f3f; } sort(a,a+1+n,cmp); for (int i=0;i<=n;i++){ int left=-1; int right=-1; for (int j=i-1;j>=0;j--){ if(left==-1 && maxx>=a[i].h-a[j].h && a[j].r>=a[i].l && a[j].l<=a[i].l){ left=j; }; if(right==-1 && maxx>=a[i].h-a[j].h && a[j].r>=a[i].r && a[j].l<=a[i].r){ right=j; } } if (left!=-1){ dp[i][0]=min(dp[left][0]+a[i].l-a[left].l,dp[left][1]+a[left].r-a[i].l); }else { if (a[i].h<=maxx)dp[i][0]=0; } if (right!=-1){ dp[i][1]=min(dp[right][0]+a[i].r-a[right].l,dp[right][1]+a[right].r-a[i].r); }else{ if (a[i].h<=maxx)dp[i][1]=0; } } printf("%d\n",dp[n][0]+y); } return 0; }
N-POJ 2533
最长递增子序列
#include<iostream> #include<algorithm> #include<string.h> #include<stdio.h> using namespace std; int a[1005]; int dp[1005]; int main(){ int n; while(~scanf("%d",&n)){ for (int i=1;i<=n;i++){ scanf("%d",&a[i]); } memset(dp,0,sizeof(dp)); for (int i=1;i<=n;i++){ dp[i]=1; for (int j=1;j<i;j++){ if (a[i]>a[j]){ dp[i]=max(dp[i],dp[j]+1); } } } int ans=0; for (int i=1;i<=n;i++){ ans=max(ans,dp[i]); } printf("%d\n",ans); } return 0; }
O-POJ 3186
区间DP
dp[i][j]选到代表从左往右第i个和从右往左第j个
那么dp[i][j]=max(dp[i-1][j]+(i+j)*a[i],d[i][j-1]+(i+j)*a[n-j+1]);
最后找出在dp[i][n-1]中最大值的即可。
#include<iostream> #include<algorithm> #include<string.h> #include<stdio.h> using namespace std; int a[2006]; int dp[2006][2006]; int main(){ int n; while(~scanf("%d",&n)){ for (int i=1;i<=n;i++){ scanf("%d",&a[i]); } for (int i=0;i<=n;i++){ for (int j=0;j+i<=n;j++){ if (i>0 && j>0){ dp[i][j]=max(dp[i-1][j]+(i+j)*a[i],dp[i][j-1]+(i+j)*a[n-j+1]); }else if (j>0){ dp[i][j]=dp[i][j-1]+j*a[n-j+1]; }else if (i>0){ dp[i][j]=dp[i-1][j]+i*a[i]; } } } int ans=0; for (int i=0;i<=n;i++){ ans=max(dp[i][n-i],ans); } printf("%d\n",ans); } return 0; }
P-HDU - 1078
DFS+DP
dp[i][j]=max(dp[i][j],dfs(i,j+k)+a[i][j]);
dp[i][j]=max(dp[i][j],dfs(i+k,j)+a[i][j]);
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> #define rep(i,j,k) for(int i=j;i<=k;i++) using namespace std; int a[115][115]; int dp[115][115]; int n,k; int dfs(int x,int y) { if (dp[x][y])return dp[x][y]; dp[x][y]=a[x][y]; for (int i=1;i<=k;i++){ if (x+i<=n && a[x+i][y]>a[x][y]){ dp[x][y]=max(dp[x][y],dfs(x+i,y)+a[x][y]); } if (x-i>=1 && a[x-i][y]>a[x][y]){ dp[x][y]=max(dp[x][y],dfs(x-i,y)+a[x][y]); } if (y+i<=n && a[x][y+i]>a[x][y]){ dp[x][y]=max(dp[x][y],dfs(x,y+i)+a[x][y]); } if (y-i>=1 && a[x][y-i]>a[x][y]){ dp[x][y]=max(dp[x][y],dfs(x,y-i)+a[x][y]); } } return dp[x][y]; } int main() { while(~scanf("%d",&n)) { memset(dp,0,sizeof(dp)); scanf("%d",&k); if (n==-1 && k==-1)break; for (int i=1; i<=n; i++) { for (int j=1; j<=n; j++) { scanf("%d",&a[i][j]); } } printf("%d\n",dfs(1,1)); } return 0; }
Q-HDU - 2859
最大对称矩阵
从左下角往右上角
那么dp[i][j]=(dp[i-1][j+1]+1,dp[i][j])同时两边新增加的横和竖也要对称长度大于dp[i-1][j+1]
否则就等于MIN（对称长度，dp[i-1][j+1])
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; int dp[1006][1006]; int n; char a[1006][1006]; int main(){ int n; while(~scanf("%d",&n) && n){ for (int i=0;i<n;i++){ scanf("%s",a[i]); } int ans=0; for (int i=0;i<n;i++){ for (int j=0;j<n;j++){ dp[i][j]=1; int x=i; int y=j; while(x>=0 && y<n && a[x][j]==a[i][y]){ x--; y++; } int len=i-x; if (len>dp[i-1][j+1]){ if (dp[i][j]<dp[i-1][j+1]+1) dp[i][j]=dp[i-1][j+1]+1; }else { dp[i][j]=len; } ans=max(ans,dp[i][j]); } } printf("%d\n",ans); } return 0; }
R-POJ 3616
翻版最长递增子序列
#include<iostream> #include<string.h> #include<algorithm> #include<stdio.h> #define LL long long using namespace std; struct node{ LL s; LL en; LL ef; }a[2006]; bool cmp(node a,node b){ if (a.s==b.s){ return a.en<b.en; }else { return a.s<b.s; } } LL dp[2006]; int main(){ int n,m,r; while(~scanf("%d%d%d",&n,&m,&r)){ memset(dp,0,sizeof(dp)); for (int i=1;i<=m;i++){ scanf("%lld%lld%lld",&a[i].s,&a[i].en,&a[i].ef); } sort(a+1,a+1+m,cmp); for (int i=1;i<=m;i++){ dp[i]=a[i].ef; for (int j=1;j<i;j++){ // cout<<a[i].s<<" "<<a[j].en<<endl; if(a[i].s>=a[j].en+r){ dp[i]=max(dp[i],dp[j]+a[i].ef); } } } LL ans=0; for (int i=1;i<=m;i++){ ans=max(ans,dp[i]); } printf("%lld\n",ans); } return 0; }
S-POJ 3666
变成有序数列的最小代价
dp[i][j]表示选到a[i]的时候，把a[i]变成数列中第j小的数。
首先我们容易写出基本的DP
dp[i][j]=abs(j-w[i])+min(dp[i-1][k]);(k<=j)
表示选到i时,以j为最大值。
他是由j-w[i]以及dp[i-1][k]中以k为最小值（k<=j）传来的
那么我只需了，遍历时维护dp[i-1][k]=min即可
方程也就写成了dp[i][j]=abs(a[i]-j)+min;
最后把j离散化即可
dp[i][j]=abs(a[i]-b[j])+min.其中b是a排序以后的值。
相当于dp[i][j]是把a[i]变成b[j]再加上以前dp[i-1][k]的最小值。
#include<iostream> #include<algorithm> #include<string.h> #include<stdio.h> using namespace std; const int N = 2005; int n; int a[N],b[N]; long long dp[N][N]; int main(){ while(~scanf("%d",&n)){ for (int i=1;i<=n;i++){ scanf("%d",&a[i]); b[i]=a[i]; } sort(b+1,b+1+n); for (int i=1;i<=n;i++){ long long mn=dp[i-1][1]; for (int j=1;j<=n;j++) { mn=min(mn,dp[i-1][j]); dp[i][j]=abs(a[i]-b[j])+mn; } } long long ans=dp[n][1]; for (int i=1;i<=n;i++){ ans=min(ans,dp[n][i]); } printf("%lld\n",ans); } return 0; }