2017暑假集训 div1 DP（1）

HDU 1024

题意：为给定一个数组，求其分成m个不相交子段和最大值的问题。

做法：很容易想到转移方程 DP[i][j]=max(DP[i][j-1],dp[i-1][k])+a[j];  n2的状态，转移又有n ，所以一共n3。

所以我们得想个办法优化一下。

优化1：可不可以在进行转移时，已经把 max dp[i][k] 预处理出来呢。答案是可以的，实现的时候加上滚动的思想

优化2：滚动数组，这是dp的常见优化

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <queue>
#include <string.h>
using namespace std;
typedef long long ll;
ll a[1000100];
ll dp[1000100];
ll pre[1000000];
int n,m;
int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        for(int i=1;i<=n;++i) scanf("%I64d",&a[i]);
        memset(pre,0,sizeof(pre));
        memset(dp,0,sizeof(dp));

        ll ma;
        for(int i=1;i<=m;++i)
        {
            ma=-0x3f3f3f3f;
            for(int j=i;j<=n;++j)
            {
                dp[j]=max(dp[j-1]+a[j],pre[j-1]+a[j]);
                pre[j-1]=ma;
                ma=max(ma,dp[j]);
            }
        }
        printf("%I64d\n",ma);
    }
    return 0;
}

HDU 1069

题意：给定n个木块，问最高垒多高（上面的木块长和宽必须都小于下面的）

做法:先按长宽排序，dp[i]表示此时最高的木块编号为I， 那就是O(n )的状态，O(n)的转移

HDU 1074

做法：状压DP ，我还不是很会，先给上神牛牪犇的代码

/*分析：对于n种家庭作业，全部做完有n!种做的顺序
但是n!太大了，且对于完成作业1,2,3和1,3,2和2,1,3和3,2,1和3,1,2来说
完成它们消耗的天数一定是一样的，只是完成的顺序不同从而扣的分不同
所以可以将完成相同的作业的所有状态压缩成一种状态并记录扣的最少分即可
即：状态压缩dp
对于到达状态i,从何种状态到达i呢？只需要枚举所有的作业
假如对于作业k,i中含有作业k已完成，那么i可以由和i状态相同的状态仅仅是k未完成的
状态j=i-(1<<k)来完成k到达,并且j一定比i小，如果状态从0枚举到2^n-1那么j一定是在i之前已经计算过的 
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;

const int MAX=(1<<15)+10;
int n;
int dp[MAX],t[MAX],pre[MAX],dea[20],fin[20];//dp[i]记录到达状态i扣的最少分,t时相应的花去多少天了
char s[20][110];

void output(int x){
	if(!x)return;
	output(x-(1<<pre[x]));
	printf("%s\n",s[pre[x]]);
}

int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		for(int i=0;i<n;++i)scanf("%s%d%d",&s[i],&dea[i],&fin[i]);
		int bit=1<<n;
		for(int i=1;i<bit;++i){//枚举到达状态i
			dp[i]=INF;//初始化到达状态i的扣分 
			for(int j=n-1;j>=0;--j){//由于输入时按字符大小输入，而每次完成j相当于把j放在后面完成且下面判断是dp[i]>dp[i-temp]+score 
				int temp=1<<j;      //所以是n-1开始，如果下面判断是dp[i]>=dp[i-temp]+score则从0开始 
				if(!(i&temp))continue;//状态i不存在作业j完成则不能通过完成作业j到达状态i
				int score=t[i-temp]+fin[j]-dea[j];//i-temp表示没有完成j的那个状态
				if(score<0)score=0;//完成j被扣分数最小是0 
				if(dp[i]>dp[i-temp]+score){
					dp[i]=dp[i-temp]+score;
					t[i]=t[i-temp]+fin[j];//到达状态i花费的时间
					pre[i]=j;//到达状态i的前驱,为了最后输出完成作业的顺序 
				} 
			}
		}
		printf("%d\n",dp[bit-1]);
		output(bit-1);//输出完成作业的顺序 
	}
	return 0;
} 

HDU 1087

最长上升子序列

HDU 1114

完全背包模板题，因为要求最小，初始化为inf

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <queue>
using namespace std;
const int inf=0x3f3f3f3f;
int val[510];
int w[510];
int dp[60000];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int e,f,v,n;
        scanf("%d%d",&e,&f);
        v=f-e;
        scanf("%d",&n);
        for(int i=0;i<n;++i) scanf("%d%d",&val[i],&w[i]);
        for(int i=0;i<=v;++i) dp[i]=inf;

        dp[0]=0;
        for(int i=0;i<n;++i)
        {
            for(int j=w[i];j<=v;++j)
            {
                dp[j]=min(dp[j],dp[j-w[i]]+val[i]);
            }
        }

        if(dp[v]==inf) printf("This is impossible.\n");
        else printf("The minimum amount of money in the piggy-bank is %d.\n",dp[v]);
    }
    return 0;
}