【STSRM12】夏令营

【题意】n个数划分成k段，每段的价值为段内不同数字的数量，求最大总价值

【算法】DP+线段树

【题解】

f[i][j]表示前i个数字划分成j段的最大价值。

f[i][j]=max(f[k][j-1]+value(k+1,j)),j-1<=k<i。

暴力复杂度O(n^3*k)，预处理value后复杂度降为O(n^2*k)。

正解考虑加入一个数字i，只能为k+1~i贡献1的价值，其中k为数字i上一次出现的位置。

那么排序预处理上一次出现位置，区间+1用线段树维护，取max用线段树查询，复杂度O(nk*log n)。

注意线段树常数……特别注意手写max。

从头查比从中间查常数小。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn=;
struct tree{int l,r,ms,delta;}t[maxn*];
struct cyc{int num,ord;}b[maxn];
bool cmp(cyc a,cyc b){return a.num<b.num||(a.num==b.num&&a.ord<b.ord);}
int f[maxn],n,kind,a[maxn],c[maxn];
void pushup(int k){t[k].ms=max(t[k<<].ms,t[k<<|].ms);}
void pushdown(int k){
    if(t[k].delta){
        t[k<<].delta+=t[k].delta;
        t[k<<].ms+=t[k].delta;
        t[k<<|].delta+=t[k].delta;
        t[k<<|].ms+=t[k].delta;
        t[k].delta=;
    }
}
void build(int k,int l,int r){
    t[k].l=l;t[k].r=r;
    if(l==r){t[k].ms=f[l];t[k].delta=;}
    else{
        int mid=(l+r)>>;
        build(k<<,l,mid);
        build(k<<|,mid+,r);
        pushup(k);
        t[k].delta=;
    }
}
void insert(int k,int l,int r,int x){
    if(l<=t[k].l&&t[k].r<=r){t[k].delta+=x;t[k].ms+=x;}
    else{
        pushdown(k);
        int mid=(t[k].l+t[k].r)>>;
        if(l<=mid)insert(k<<,l,r,x);
        if(r>mid)insert(k<<|,l,r,x);
        pushup(k);
    }
}
int query(int k,int l,int r){
    if(l<=t[k].l&&t[k].r<=r)return t[k].ms;
    else{
        pushdown(k);
        int mid=(t[k].l+t[k].r)>>;
        int ans=;
        if(l<=mid)ans=query(k<<,l,r);
        if(r>mid)ans=max(ans,query(k<<|,l,r));
        return ans;
    }
}
int main(){
    scanf("%d%d",&n,&kind);
    for(int i=;i<=n;i++){scanf("%d",&a[i]);b[i].num=a[i];b[i].ord=i;}
    sort(b+,b+n+,cmp);
    for(int i=;i<=n;i++)if(b[i].num==b[i-].num)c[b[i].ord]=b[i-].ord;
    build(,,n);
    for(int j=;j<=kind;j++){
        for(int i=;i<=n;i++){
            insert(,c[i],i-,);
            f[i]=query(,,i-);
        }
        build(,,n);
    }
    printf("%d",f[n]);
    return ;
}

暴力AC法：打表容易发现具有决策单调性，原因在于加入i时已知i-1的决策点j比左边优，加入i后对i上一次出现的位置到i有贡献，如果左边有贡献则j一定有贡献，所以决策点k>=j。

决策单调性可以用分支决策维护，复杂度O(n^2*k*log n)。

瓶颈在快速求区间数字个数，用主席树维护，复杂度O(nk*log n)。

#include<cstdio>
#include<cstring>
#include<cctype>
#include<cmath>
#include<algorithm>
#define ll long long
using namespace std;
int read()
{
    char c;int s=,t=;
    while(!isdigit(c=getchar()))if(c=='-')t=-;
    do{s=s*+c-'';}while(isdigit(c=getchar()));
    return s*t;
}
/*------------------------------------------------------------*/
const int inf=0x3f3f3f3f,maxn=;

int n,kind,f[][maxn],a[maxn],x,dfsnum=,b[maxn];
bool c[maxn];
int work(int x,int y){
    dfsnum++;
    int ans=;
    for(int i=x;i<=y;i++)if(b[a[i]]!=dfsnum){
        b[a[i]]=dfsnum;
        ans++;
    }
    return ans;
}
void find(int l,int r,int L,int R)
{
    if(l>r||L>R)return;
    int mid=(l+r)>>;
    int w,v=-inf+;
    for(int i=L;i<=R&&i<mid;i++){
        if(f[-x][i]+work(i+,mid)>v){
            v=f[-x][i]+work(i+,mid);
            w=i;
        }
    }
    f[x][mid]=v;
    find(l,mid-,L,w);
    find(mid+,r,w,R);
}
int main()
{
    scanf("%d%d",&n,&kind);
    for(int i=;i<=n;i++)scanf("%d",&a[i]);
    x=;
    for(int j=;j<=kind;j++){
        x=-x;
        f[x][]=-inf;
        find(,n,,n-);
    }
    printf("%d",f[x][n]);
    return ;
}

O(n^2*k*log n)