kuangbin带你飞 专题十二 基础DP1

好久没做DP了,虽说是基础DP1吧,第一题就把我海虐了

感觉DP真是看脑洞,最近脑子各种混乱睡眠也不足,还是得要好好理解的

HDU 1024

题意:最大m段区间和啊

题解:这题正常的方法都会MLE 啊TLE啊

dp[i][j]这个数组表示前j个元素中取i段的最大值,并且取了a[j]

自然是开不下二维的

于是要用一维滚动数组(这方面我真是不行,滚动数组很久以前也学过,一碰到难题就想不出)

用dp[j]表示取了a[j]情况下的当前一层(取多少组区间)的最大值,然后要开个num[j]数组,记录1-j情况下(上一层)取到的最大值

先是循环1-m,表示当前是取了多少个区间,然后元素从i-n遍历(因为前面取了i-1层,至少有i-1个元素,所以j从i开始考察)

第i层的dp[j]是第i层的dp[j-1]+a[j],(把a[j-1]和a[j]看在一起),或者是num[j-1]+a[j]。

要开个maxn记录这一层dp[1-j]的最大值,然后赋值给num[j],由于到达i+1层之后num[i]就不成立了所以一直开始maxn赋值是INF,然后maxn=max(maxn,dp[j]),在j+1的时候赋值给num[j]

另外我开LL 会TLE,然后比较虚,看discuss里说int也能过,果然

int a[MAX];
int dp[MAX];
int num[MAX];

int main(){
    int n,m;
    while(~scanf("%d%d",&m,&n)){
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        mem0(dp);
        mem0(num);
        int maxn;
        for(int i=1;i<=m;i++){
            maxn=-INF;
            for(int j=i;j<=n;j++){
                dp[j]=max(dp[j-1],num[j-1])+a[j];
                num[j-1]=maxn;
                maxn=max(dp[j],maxn);
            }
        }
        printf("%d\n",maxn);
    }
    return 0;
}

poj 1015

在遥远的国家佛罗布尼亚,嫌犯是否有罪,须由陪审团决定。陪审团是
由法官从公众中挑选的。先随机挑选n 个人作为陪审团的候选人,然后
再从这n 个人中选m 人组成陪审团。选m 人的办法是:控方和辩方会
根据对候选人的喜欢程度,给所有候选人打分,分值从0 到20。为了
公平起见,法官选出陪审团的原则是:选出的m 个人,必须满足辩方
总分和控方总分的差的绝对值最小。如果有多种选择方案的辩方总分
和控方总分的之差的绝对值相同,那么选辩控双方总分之和最大的
方案即可。最终选出的方案称为陪审团方案。
    为叙述问题方便,现将任一选择方案中,辩方总分和控方总分
之差简称为“辩控差”,辩方总分和控方总分之和称为“辩控和”。
第i 个候选人的辩方总分和控方总分之差记为V(i),辩方总分和控
方总分之和记为S(i)。现用f(j, k)表示,取j 个候选人,使其辩
控差为k 的所有方案中,辩控和最大的那个方案(该方案称为“方
案f(j, k)”)的辩控和。并且,我们还规定,如果没法选j 个人,
使其辩控差为k,那么f(j, k)的值就为-1,也称方案f(j, k)不可行。
本题是要求选出m 个人,那么,如果对k 的所有可能的取值,求
出了所有的f(m, k) (-20×m≤ k ≤ 20×m),那么陪审团方案
自然就很容易找到了。
    问题的关键是建立递推关系。需要从哪些已知条件出发,
才能求出f(j, k)呢?显然,方案f(j, k)是由某个可行的方案f(j-1, x)
( -20×m ≤ x ≤ 20×m)演化而来的。可行方案f(j-1, x)能演化成
方案f(j, k)的必要条件是:存在某个候选人i,i 在方案f(j-1, x)中
没有被选上,且x+V(i) = k。在所有满足该必要条件的f(j-1, x)中,
选出 f(j-1, x) + S(i) 的值最大的那个,那么方案f(j-1, x)再加上候选人i,
就演变成了方案 f(j, k)。这中间需要将一个方案都选了哪些人都记录下来。
不妨将方案f(j, k)中最后选的那个候选人的编号,记在二维数组的
元素path[j][k]中。那么方案f(j, k)的倒数第二个人选的编号,
就是path[j-1][k-V[path[j][k]]。假定最后算出了解方案的辩控差是k,
那么从path[m][k]出发,就能顺藤摸瓜一步步求出所有被选中的候选人。
初始条件,只能确定f(0, 0) = 0。由此出发,一步步自底向上递推,
就能求出所有的可行方案f(m, k)( -20×m ≤ k ≤ 20×m)。实际解题
的时候,会用一个二维数组f 来存放f(j, k)的值。而且,由于题目中辩
控差的值k 可以为负数,而程序中数租下标不能为负数,所以,在程序中
不妨将辩控差的值都加上400,以免下标为负数导致出错,即题目描述中,
如果辩控差为0,则在程序中辩控差为400。

这题好难,自己瞎搞了好久都跪了,然后就看kuangbin大神的题解,确实厉害啊

#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
#define   MAX       205
#define   MAXN      10005
#define   lson      l,m,rt<<1
#define   rson      m+1,r,rt<<1|1
#define   lrt       rt<<1
#define   rrt       rt<<1|1
#define   mid       int m=(r+l)>>1
#define   LL        long long
#define   ull       unsigned long long
#define   mem0(x)   memset(x,0,sizeof(x))
#define   mem1(x)   memset(x,-1,sizeof(x))
#define   meminf(x) memset(x,INF,sizeof(x))
#define   lowbit(x) (x&-x)

const int    mod   = 1000000007;
const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const int    INFF  = 1e9;
const double pi    = 3.141592653589793;
const double inf   = 1e18;
const double eps   = 1e-10;

int path[25][805];//记录j,k状态下选择的是第几个人
int d[MAX],p[MAX];
int dp[25][805];//第二维是辩控差,数组记录辩控和
int num[MAX];
int main(){
    int n,m;
    int kase=0;
    while(scanf("%d%d",&n,&m)&&n){
        kase++;
        for(int i=1;i<=n;i++) scanf("%d%d",&p[i],&d[i]);
        mem1(path);
        mem1(dp);
        int mm=m*20;//辩控差0转化为mm
        dp[0][mm]=0;
        for(int j=1;j<=m;j++){
            for(int k=0;k<=2*mm;k++){
                if(dp[j-1][k]>=0){//情况可行
                    for(int i=1;i<=n;i++){
                        if(dp[j-1][k]+p[i]+d[i]>dp[j][k+p[i]-d[i]]){//前一种情况加上第i个人,大于此时j个人的情况,类似于背包
                            int t1=j-1,t2=k;
                            while(t1>0&&path[t1][t2]!=i){//检查前j-1个人中有没有i
                                t2-=p[path[t1][t2]]-d[path[t1][t2]];
                                t1--;
                            }
                            if(t1==0){//没有出现过i
                                dp[j][k+p[i]-d[i]]=dp[j-1][k]+p[i]+d[i];
                                path[j][k+p[i]-d[i]]=i;
                            }
                        }
                    }
                }
            }
        }
        int j=mm;
        int i=0;
        int tmp;
        while(dp[m][j-i]<0&&dp[m][j+i]<0) i++;//看辩控差最小是多少
        if(dp[m][j+i]>dp[m][j-i]) tmp=j+i;//取辩控和大的
        else tmp=j-i;
        int tot=0;
        for(int i=path[m][tmp],t=tmp,j=m;i!=-1&&j>0;i=path[j][t]){
            j--;
            t-=p[i]-d[i];
            num[tot++]=i;//顺着找回去
        }
        sort(num,num+tot);
        printf("Jury #%d\n",kase);
        printf("Best jury has value %d for prosecution and value %d for defence:\n",(dp[m][tmp]+tmp-mm)/2,(dp[m][tmp]-tmp+mm)/2);
        for(int i=0;i<tot;i++) printf(" %d",num[i]);
        printf("\n\n");
    }
    return 0;
}


HDU 1160

题意:给你一些老鼠,有质量和速度两个参数,让你找到最多的老鼠的排列,让他们质量递增,速度递减

题解:dp[i]表示选择第i只老鼠作为最后一只的时候最多能选多少只,先对老鼠的质量升序排序,速度降序,然后dp[i]=max(dp[k])k<i;

就这样遍历,o(n^2)的复杂度可以过,然后开个vector记录路径,当前dp[i]最优解的情况下的序号


#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;
#define   MAX       1005
#define   MAXN      10005
#define   lson      l,m,rt<<1
#define   rson      m+1,r,rt<<1|1
#define   lrt       rt<<1
#define   rrt       rt<<1|1
#define   mid       int m=(r+l)>>1
#define   LL        long long
#define   ull       unsigned long long
#define   mem0(x)   memset(x,0,sizeof(x))
#define   mem1(x)   memset(x,-1,sizeof(x))
#define   meminf(x) memset(x,INF,sizeof(x))
#define   lowbit(x) (x&-x)

const int    mod   = 1000000007;
const int    prime = 999983;
const int    INF   = 0x3f3f3f3f;
const int    INFF  = 1e9;
const double pi    = 3.141592653589793;
const double inf   = 1e18;
const double eps   = 1e-10;

struct mice{
    int w,s,id;
    bool operator < (const mice &a) const{
        if(w==a.w) return s>a.s;
        return w<a.w;
    }
}p[MAX];

vector<int> v[MAX];
int dp[MAX];

int main(){
    int xcount=1;
    int a,b;
    while(~scanf("%d%d",&a,&b)){
        p[xcount]=(mice){a,b,xcount};
        xcount++;
    }
    sort(p+1,p+xcount);
    int ans=0;
    int cnt=0;
    for(int i=1;i<xcount;i++){
        dp[i]=1;
        int maxn=0;
        int flag=-1;
        for(int j=1;j<i;j++){
            if(p[i].w>p[j].w&&p[i].s<p[j].s){
                if(maxn<dp[j]){
                    maxn=dp[j];
                    flag=j;
                }
            }
        }
        if(flag!=-1){
            dp[i]+=maxn;
            for(int k=0;k<v[flag].size();k++){
                v[i].push_back(v[flag][k]);
            }
            if(ans<dp[i]){
                ans=dp[i];
                cnt=i;
            }
        }
        v[i].push_back(p[i].id);
    }
    printf("%d\n",ans);
    for(int i=0;i<v[cnt].size();i++){
        printf("%d\n",v[cnt][i]);
    }
    return 0;
}


你可能感兴趣的:(ACM)