BZOJ4380: [POI2015]Myjnie（区间DP）

传送门

有n家洗车店从左往右排成一排，每家店都有一个正整数价格p[i]。
有m个人要来消费，第i个人会驶过第a[i]个开始一直到第b[i]个洗车店，且会选择这些店中最便宜的一个进行一次消费。但是如果这个最便宜的价格大于c[i]，那么这个人就不洗车了。
请给每家店指定一个价格，使得所有人花的钱的总和最大。

题解：区间DP

好题。
首先观察数据可以知道这个DP肯定是$n^2m$或者$n^3m$的，区间有个$n^2$，状态估计应该是$n^2m$的。。

接下来，空间跟m有关，肯定要离散化，而且观察到答案每一位上肯定是$c_i$，那么记录$v[l][r][val]$表示区间中最小值是val的最大收益。

那么接下来的$dp$就很简单了：
预处理$cnt[l][r][val]$表示区间中包含的人的限制$\ge val$的个数。对于一个状态$v[l][r][val]$可以从$\max\{v[l][mid-1][val_1]\}+\max\{v[mid+1][r][val_2]\}$转移$(val_1,val2\ge val)$，而且还要加上本区间包含且两端区间不包含的限制$\ge val$的值，这个记录一个前缀和就好了，对于前面的一个取max操作也可以采用类似的方法。

题目还要求输出方案，那么再记录一个每个状态的max是由哪一个c决定的就好了$(c\ge val)$。状态数$n^2m$，转移$O(n)$，时间复杂度$O(n^3m)$。

因为我全用记忆化搜索实现，传参很多，直接排到的$rank$的最后一名，不过思想还是可以借鉴的。

#include<bits/stdc++.h>
using namespace std;
const int Maxn=53,Maxm=4e3+20;
struct IO{
    streambuf *ib,*ob;
    inline void init(){
        ios::sync_with_stdio(false);
        cin.tie(NULL);cout.tie(NULL);
        ib=cin.rdbuf();ob=cout.rdbuf();
    }
    inline int read(){
        char ch=ib->sbumpc();int i=0,f=1;
        while(!isdigit(ch)){if(ch=='-')f=-1;ch=ib->sbumpc();}
        while(isdigit(ch)){i=(i<<1)+(i<<3)+ch-'0';ch=ib->sbumpc();}
        return i*f;
    }
    inline void W(int x){
        static int buf[50];
        if(!x){ob->sputc('0');return;}
        if(x<0){ob->sputc('-');x=-x;}
        while(x){buf[++buf[0]]=x%10;x/=10;}
        while(buf[0]){ob->sputc(buf[buf[0]--]+'0');}
    }
}io;
const int INF=0x3f3f3f3f;
typedef pair<int,int> pii;
struct node{
    int pos,pre;
    pii v;
}dp[Maxn][Maxn][Maxm],*null=&dp[0][0][0];//[l,r],c
int n,m,rk[Maxm],l[Maxm],r[Maxm],c[Maxm],cnt[Maxn][Maxn][Maxm],mxval,ans,tot;
pair<int,int>b[Maxm];
typedef pair<int,int> pii;
inline node* Dp(int l,int r,int c){
    if(l>r||c>tot)return null;
    if(dp[l][r][c].v.first!=-1)return &dp[l][r][c];
    dp[l][r][c].v.first=0;
    if(l==r){
        dp[l][r][c].v.first=cnt[l][l][c]*rk[c];dp[l][r][c].pos=l;
        dp[l][r][c].pre=(c!=tot&&Dp(l,r,c+1)->v.second>dp[l][r][c].v.first)?Dp(l,r,c+1)->pre:c;
        dp[l][r][c].v.second=max(dp[l][r][c].v.first,Dp(l,r,c+1)->v.second);
        return &dp[l][r][c];
   }
    int pos,mx=0;
    for(int k=l,val;k<=r;k++){
        val=Dp(l,k-1,c)->v.second+Dp(k+1,r,c)->v.second+rk[c]*(cnt[l][r][c]-cnt[l][k-1][c]-cnt[k+1][r][c]);
        if(val>=mx)pos=k,mx=val;
    }
    dp[l][r][c].pos=pos;
    dp[l][r][c].pre=(c!=tot&&Dp(l,r,c+1)->v.second>mx)?(Dp(l,r,c+1)->pre):c;
    dp[l][r][c].v.first=mx;
    dp[l][r][c].v.second=max(mx,Dp(l,r,c+1)->v.second);
    return &dp[l][r][c];
}
inline void W(const node &now,int l,int r,int mxv){
    int pre=dp[l][now.pos-1][mxv].pre;
    if(l<now.pos&&pre)W(dp[l][now.pos-1][pre],l,now.pos-1,pre);
    io.W(rk[mxv]);io.ob->sputc(' ');
    int suf=dp[now.pos+1][r][mxv].pre;
    if(r>now.pos&&suf)W(dp[now.pos+1][r][suf],now.pos+1,r,suf);
}
int main(){
    io.init();n=io.read();m=io.read();
    for(int i=1;i<=m;i++){
        l[i]=io.read();r[i]=io.read();c[i]=io.read();
        b[i]=make_pair(c[i],i);
    }
    sort(b+1,b+m+1);
    for(int i=1;i<=m;i++){
        if(i==1||b[i].first!=b[i-1].first)++tot;
        rk[tot]=c[b[i].second];c[b[i].second]=tot;
    }
    for(int i=1;i<=n;i++){
        for(int j=i;j<=n;j++){
            for(int k=1;k<=tot;k++){
                dp[i][j][k].v.first=-1;
            }
        }
    }
    for(int i=1;i<=m;i++){
        for(int j=1;j<=l[i];j++){
            for(int k=r[i];k<=n;k++){
                cnt[j][k][c[i]]++;
            }
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=i;j<=n;j++){
            for(int c=tot;c>=1;c--){
                cnt[i][j][c]+=cnt[i][j][c+1];
            }
        }
    }
    for(int i=tot;i>=1;i--){
        if(mxval<Dp(1,n,i)->v.first)ans=i,mxval=Dp(1,n,i)->v.first;       
    }
    io.W(mxval);io.ob->sputc('\n');
    W(dp[1][n][ans],1,n,ans);
}