bzoj 4069~4071 APIO2015

T1

从高到底按位确定答案

A=1时f[i]表示前i个数合法的划分至少需要分出几段，时间复杂度$O(n^2log(ans))$

A>1时f[i][j]表示前i个数划分为j段是否可能合法，转移显然，时间复杂度$O(n^3log(ans)/32)$

#include<cstdio>
#include<cstring>
#include<bitset>
typedef long long i64;
int n,A,B;
int f[];
i64 s[],ans=;
std::bitset<>d[];
int main(){
    scanf("%d%d%d",&n,&A,&B);
    for(int i=;i<=n;++i)scanf("%lld",s+i),s[i]+=s[i-];
    if(A==){
        for(int x=;x>=;--x){
            i64 v=ans|((1ll<<x)-);
            for(int i=;i<=n;++i){
                f[i]=0x3f3f3f3f;
                for(int j=;j<i;++j)if(((s[i]-s[j])|v)==v&&f[j]+<f[i])f[i]=f[j]+;
            }
            if(f[n]>B)ans|=1ll<<x;
        }
    }else{
        d[][]=;
        for(int x=;x>=;--x){
            i64 v=ans|((1ll<<x)-);
            for(int i=;i<=n;++i){
                d[i].reset();
                for(int j=;j<i;++j)if(((s[i]-s[j])|v)==v)
                d[i]|=d[j]<<;
            }
            bool dd=;
            for(int i=A;i<=B;++i)dd|=d[n][i];
            if(!dd)ans|=1ll<<x;
        }
    }
    printf("%lld\n",ans);
    return ;
}

T2

对每个不同的(p[i],b[i]%p[i])，新建一些点表示这个i可以走到的位置，每个位置和每个i也建出对应的点

最后可以转为01边权最短路

可以证明时空复杂度均为$O(n^\frac 3 2)$

#include<bits/stdc++.h>
const int inf=0x3f3f3f3f,C=;
int n,m,b[],p[],B;
struct edge{
    int to;
    edge*nx;
}*ep=,*mep=;
edge*e0[*C];
int l[*C];
bool is[*C];
void ae(int a,int b){
    if(ep==mep)ep=new edge[],mep=ep+;
    *ep=(edge){b,e0[a]};
    e0[a]=ep++;
}
int idp;
struct node{int w,l;void upd1(int);};
std::deque<node>q;
std::map<int,int>mp;
void node::upd1(int u){
    if(::l[u]>l+)q.push_back((node){u,::l[u]=l+});
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=;i<m;++i)scanf("%d%d",b+i,p+i);
    idp=n+m;
    for(int i=;i<m;++i){
        ae(b[i],n+i);
        ae(n+i,b[i]);
        int x=p[i],y=b[i]%x;
        int&z=mp[x<<|y];
        if(!z){
            z=idp;
            int a;
            for(a=y;a+x<n;a+=x){
                is[idp]=;
                ae(idp++,a);
            }
            ae(idp++,a);
        }
        ae(n+i,z+(b[i]-y)/x);
    }
    std::fill(l,l+idp+,inf);
    q.push_back((node){n,l[n]=});
    while(!q.empty()){
        node w=q.front();q.pop_front();
        if(w.l!=l[w.w])continue;
        if(w.w==n+)return printf("%d\n",w.l),;
        for(edge*i=e0[w.w];i;i=i->nx){
            int u=i->to;
            if(l[u]>w.l)q.push_front((node){u,l[u]=w.l});
        }
        if(is[w.w-])w.upd1(w.w-);
        if(is[w.w])w.upd1(w.w+);
    }
    return puts("-1"),;
}

T3

对同侧的直接计算贡献，否则考虑不同侧的

K=1，中位数位置最优

K=2，可以证明按$S_i+T_i$排序后划分成左右两部分后按K=1的情况处理，能找到最优解

带插入的中位数可以用对顶堆维护

时间复杂度$O(nlogn)$

#include<bits/stdc++.h>
typedef long long i64;
int k,n;
char s1[],s2[];
int p1,p2,xs[],xp=;
i64 ans=;
int abs(int x){return x>?x:-x;}
struct pos{
    int a,b;
    bool operator<(pos w)const{return a+b<w.a+w.b;}
}ps[];
int pp=;
i64 ss1=,ss2=,f[];
std::priority_queue<int>q1;
std::priority_queue<int,std::vector<int>,std::greater<int> >q2;
void init(){
    q1=std::priority_queue<int>();
    q2=std::priority_queue<int,std::vector<int>,std::greater<int> >();
    ss1=ss2=;
}
void ins(int x){
    if(q1.size()&&x<=q1.top()){
        q1.push(x),ss1+=x;
        if(q1.size()>q2.size()+){
            int x=q1.top();q1.pop();
            ss1-=x;ss2+=x;
            q2.push(x);
        }
    }else{
        q2.push(x),ss2+=x;
        if(q2.size()>q1.size()+){
            int x=q2.top();q2.pop();
            ss2-=x;ss1+=x;
            q1.push(x);
        }
    }
}
void mins(i64&a,i64 b){if(a>b)a=b;}
i64 cal(){
    return ss2-ss1;
}
int main(){
    scanf("%d%d",&k,&n);
    if(k==){
        for(int t=;t<n;++t){
            scanf("%s%d%s%d",s1,&p1,s2,&p2);
            if(s1[]==s2[])ans+=abs(p2-p1);
            else ++ans,xs[xp++]=p1,xs[xp++]=p2;
        }
        if(xp){
            std::nth_element(xs,xs+xp/,xs+xp);
            int x=xs[xp/];
            for(int a=;a<xp;++a)ans+=abs(xs[a]-x);
        }
    }else{
        for(int t=;t<n;++t){
            scanf("%s%d%s%d",s1,&p1,s2,&p2);
            if(s1[]==s2[])ans+=abs(p2-p1);
            else ++ans,ps[pp++]=(pos){p1,p2};
        }
        std::sort(ps,ps+pp);
        if(pp){
            init();
            for(int a=;a<pp;++a){
                ins(ps[a].a);ins(ps[a].b);
                f[a]=cal();
            }
            i64 mx=f[pp-];
            init();
            for(int a=pp-;a;--a){
                ins(ps[a].a);ins(ps[a].b);
                mins(mx,cal()+f[a-]);
            }
            ans+=mx;
        }
    }
    printf("%lld\n",ans);
    return ;
}