二分与分治

好神啊好神啊.....

大概就是,对于一个询问,我们可以二分答案求出结果的话......

那么对于一大堆询问,我们一起二分它们的答案......

然后,我们通过某种简化的判定条件来决定询问应该被分到左边还是右边.

把当前处理的询问扫一遍,求出应该往左递归的询问和往右递归的询问. 然后把左边的询问堆到一起,往下传.

注意我们可能需要维护一些附加信息.....看题...

 

AC VIJOS 1081 野生动物园

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

const int INF=(1<<30)-1;

int n,m;

struct query
{ int l,r,k,res; int id; };
query op[50050];
bool cmp(const query&a,const query&b)
{ return a.id < b.id; }

int a[100050];
int loc[100050];
int cnt[100050];
    
void DC(query*q,int qcnt,int*p,int pcnt,int l,int r)
{
    if(qcnt==0) return ;
    if(l==r) { for(int i=0;i<qcnt;i++) q[i].res=l; return ; }
    
    int mid=(l+r)>>1;
    
    //solve. count amount of number larger than s
    // for each operation in Q.
    
    //pre process for count.
    int tot=0;
    for(int i=0;i<pcnt;i++) 
    if(a[p[i]]<=mid) loc[tot++]=p[i];
    sort(loc,loc+tot);
    loc[tot++]=INF;
    
    //count.
    for(int i=0;i<qcnt;i++)
    cnt[i]=int(upper_bound(loc,loc+tot,q[i].r)-lower_bound(loc,loc+tot,q[i].l));
    
    int vt=0;
    int qt=0; //these are the COUNTERs
    for(int i=0;i<pcnt;i++) if(a[p[i]]<=mid) swap(p[vt],p[i]),vt++;
    for(int i=0;i<qcnt;i++) 
        if(q[i].k<=cnt[i]) swap(q[i],q[qt]),qt++;
        else q[i].k-=cnt[i];
    
    DC(q,qt,p,vt,l,mid);
    DC(q+qt,qcnt-qt,p+vt,pcnt-vt,mid+1,r);
}

int preloc[100050];

int main()
{
    n=getint();
    m=getint();
    int miv=INF;
    int mxv=-INF;
    for(int i=0;i<n;i++)
    a[i]=getint(),mxv=max(mxv,a[i]),miv=min(miv,a[i]);
    for(int i=0;i<m;i++)
    {
        int l=getint()-1;
        int r=getint()-1;
        int k=getint();
        op[i]=(query){l,r,k,0,i};
    }
    
    for(int i=0;i<n;i++) preloc[i]=i;
    DC(op,m,preloc,n,miv,mxv);
    
    sort(op,op+m,cmp);
    
    for(int i=0;i<m;i++)
    printf("%d
",op[i].res);
    
    return 0;
}

找个简单题练手.......

 

看哈,我们二分操作不是要对每个询问判断:在区间中,有多少个数比mid小嘛?

那么我们把这个区间里面所有的数扫一遍,统计比mid大的数的个数.

但是多个询问不允许我们直接扫.

 

论文给出的解决方法是,

求出所有能力值属于当前二分到的左权值区间(l,mid)的狮子的下标.

对其排序并用询问的区间进行二分. upper_bound-lower_bound就行了.

这样可以用 $log$ 级别的时间求出每个区间的比mid小的数的个数.

运用整体二分算法的关键就在于此. 我们加速的方式,就是快速求出一堆询问的二分判定.

简单地说,就是,给你一堆询问,问你,哪些询问的结果应该被分到左区间? 哪些在右区间?

解决这个问题的复杂度如果为 $f(k)$ ,那么算法总的复杂度为 $f(n)log{v}$ .

最终复杂度是 $O(log{v} log{n}( m+n))$ ,比可持久化线段树慢三分之一.

 

AC POI2011 Meteors

从这里看的题目和题解 http://victorwonder.is-programmer.com/posts/70210.html?utm_source=tuicool

讲得非常清楚..... 然后题目可以在下边这个网站交......

http://main.edu.pl/en

 神奇的网站.....神奇的题库.....神奇的题目....

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

const ll INF=((ll)1<<56)-1;


int n,m,k;


ll cty[305000]; //station belongs to
ll ask[305000]; //meteors asked for countries.

struct op
{ int l,r; ll v; } M[305000];

struct edge { int in; edge*nxt; };
int ecnt=5000; edge*et;
edge*eds[305000];
void addedge(int a,int b)
{
    if(ecnt==5000){ecnt=0;et=new edge[5000];}
    et->in=b; et->nxt=eds[a]; eds[a]=et++; ecnt++;
}
#define FOREACH_SON(i,x) for(edge*i=eds[x];i;i=i->nxt) 

int stp[305000];
int res[305000];

struct SegTree
{
    ll tag[1205000]; //SegTree tags
    int cl,cr; ll cv;
    void Change(int x=1,int l=0,int r=m-1)
    {
        if(cl<=l && r<=cr) { tag[x]+=cv; return ; }
        int mid=(l+r)>>1;
        if(mid>=cl) Change(x<<1,l,mid);
        if(mid<cr) Change(x<<1|1,mid+1,r);
    }
    ll Query(int p)
    {
        int x=1,l=0,r=m-1;
        ll res=0;
        while(l!=r)
        {
            res+=tag[x];
            if(res>INF) break;
            int mid=(l+r)>>1;
            if(p<=mid) { x<<=1; r=mid; }
            else { x=x<<1|1; l=mid+1; } 
        }
        res+=tag[x];
        return res;
    }
}T;

ll dc[605000];
void DC(int*p,int pt,int l,int r)
{
    if(l==r) { for(int i=0;i<pt;i++) res[p[i]]=l; return ; }
    
    int mid=(l+r)>>1;
    
    //brute force to deal with the querys.
    for(int i=l;i<=mid;i++)
    {
        T.cv=M[i].v;
        
        if(M[i].l<=M[i].r)
        T.cl=M[i].l,T.cr=M[i].r,T.Change();
        else
        {
            T.cl=M[i].l,T.cr=m-1,T.Change();
            T.cl=0,T.cr=M[i].r,T.Change();
        }
    }
    
    for(int i=0;i<pt;i++) FOREACH_SON(e,p[i]) //....what's the complexity?
    { dc[p[i]]+=T.Query(e->in); if(dc[p[i]]>=ask[p[i]]) break; } 
    
    for(int i=l;i<=mid;i++)
    {
        T.cv=-M[i].v;
        
        if(M[i].l<=M[i].r)
        T.cl=M[i].l,T.cr=M[i].r,T.Change();
        else
        {
            T.cl=M[i].l,T.cr=m-1,T.Change();
            T.cl=0,T.cr=M[i].r,T.Change();
        }
    }
    
    int nxp=0;
    for(int i=0;i<pt;i++)
    if(dc[p[i]]>=ask[p[i]]) swap(p[i],p[nxp++]);
    
    for(int i=nxp;i<pt;i++)
    ask[p[i]]-=dc[p[i]]; //this will not meet the breaks above.
    
    for(int i=0;i<pt;i++)
    dc[p[i]]=0; //reverse edit.
    
    DC(p,nxp,l,mid);
    DC(p+nxp,pt-nxp,mid+1,r);
}

int main()
{
    n=getint(); //amount of countries
    m=getint(); //amount of stations
    
    for(int i=0;i<m;i++)
    addedge(getint()-1,i); //set station i to country getint()-1;
    
    for(int i=0;i<n;i++)
    ask[i]=getint();
    
    k=getint();
    for(int i=0;i<k;i++)
    {
        M[i].l=getint()-1;
        M[i].r=getint()-1;
        M[i].v=getint();
    }
    M[k].l=0; M[k].r=m-1; M[k].v=INF; //to change all NIE into a solution.
    
    for(int i=0;i<n;i++) stp[i]=i; //pointers assign.
    DC(stp,n,0,k);
    
    for(int i=0;i<n;i++)
    if(res[i]==k) printf("NIE
");
    else printf("%d
",res[i]+1);
    
    return 0;
}

实现用线段树,时间复杂度(大概)为 $O(log{v}log{m}n)$ 

人家用树状数组比我快三倍TAT

 

如果对单个询问进行二分,那就是二分一下时间,设中间的时间为 $mid$ .

显然要对询问(就是每个国家的陨石收集量)进行统计. 直接暴力,对每组陨石使用线段树或者树状数组,

维护区间和,询问单点值(嗯没错,把当前国家的空间站枚举一遍做统计就好了).......

统计完以后,按照国家收集的陨石数量超过/不超过需求量,把国家分成左右两部分....

然后,清空统计用的数组.注意一定要反向修改.....不能直接memset.....

 

需要注意的地方....

1.呃........动态加边加点一定要记得计数器加意加二什么的....!!!!!!

2.我们在数组里边存的是当前考虑的国家的编号. 注意在我们的操作过程中要改变那个编号数组,所以统计数组绝对不能省掉编号!(就是说,程序中d[p[i]]不能被修改成d[i],如果不再附加数组记录一些信息的话.)

 

 

---

cdq分治

AC BZOJ 1492 NOI2007 Cash

故意不去掉注释....这个题写的我想死啊........

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

inline double getdb()
{ double x; scanf("%lf",&x); return x; }

struct point //also vector
{
    ldb x,y; point(){} point(ldb a,ldb b):x(a),y(b){}
    ldb operator*(point f) { return x*f.y-y*f.x; }
    point operator-(point f) { return point(x-f.x,y-f.y); }
    point operator()(point f) { return point(f.x-x,f.y-y); }
};

inline bool ConvexChange(point&a,point&s1,point&s2)
//Should s1 be thrown from convex when I add a new point a?
{ return s1(a)*s2(a)<=0.0; }

inline bool SlopeBetter(point&a,point&b,ldb k)
//Is a better than b when slope is k?
{ return a.y-b.y >= k*(a.x-b.x); }

bool cmpdec(const ldb&a,const ldb&b)
{ return a>=b; }

ldb d[105000];
ldb A[105000];
ldb B[105000];
ldb R[105000];

ldb X[105000];
ldb Y[105000];
ldb K[105000];
bool kcmp(const int&a,const int&b)
{ return K[a]>=K[b]; }

point s[105000]; int st;

int h[105000]; //pointers for increasing slope.
int q[105000]; //merge sort auxiliary array.
int p[105000]; //pointers for increasing x coordinate.
void DC(int l,int r)
{
    if(l==r)  
    {
        d[l]=max(d[l-1],d[l]);
        Y[l]=d[l]/(R[l]*A[l]+B[l]);
        X[l]=Y[l]*R[l];
        //printf("solved: %d %.4f %.4f %.4f
",l,(db)d[l],(db)X[l],(db)Y[l]);
        return ;
    }
    int mid=(l+r)>>1;
    
    //divide h into two parts.
    //then throw the left part to the left DC.
    //and use right part for this function.
    //and throw right part to the right DC.
    //printf("[%d,%d]%d h(o):",l,r,mid); for(int i=l;i<=r;i++) printf("%d ",h[i]); printf("
");
    
    int p1=l,p2=mid+1;
    for(int i=l;i<=r;i++)
    if(h[i]<=mid) q[p1++]=h[i]; else q[p2++]=h[i];
    memcpy(h+l,q+l,sizeof(int)*(r-l+1));
    
    //printf("[%d,%d]%d h(d):",l,r,mid); for(int i=l;i<=r;i++) printf("%d ",h[i]); printf("
");
    
    DC(l,mid); //this will set queries in [l,mid] to correct ans.
    
    //build convex.
    st=0;
    s[st++]=point(0,0); //nothing to transfer.?
    for(int i=l;i<=mid;i++)
    {
        point c(X[p[i]],Y[p[i]]);
        //printf("coordinate of %d is (%.4f,%.4f)
",p[i],(db)X[p[i]],(db)Y[p[i]]);
        while(st>1 && ConvexChange(c,s[st-1],s[st-2])) st--;
        s[st++]=c;
    }
    
    //printf("Final Convex: ");for(int i=0;i<st;i++) printf("(%.4f,%.4f)",(db)s[i].x,(db)s[i].y); printf("
");
    
    //set queries in [mid+1,r] an answer.
    int t=0;
    //printf("h for trans: ");for(int i=mid+1;i<=r;i++) printf("%.4f ",(db)K[h[i]]); printf("
");
    //printf("[%d,%d] h for trans: ",l,r);for(int i=mid+1;i<=r;i++) printf("%d ",h[i]); printf("
");
    for(int i=mid+1;i<=r;i++)
    {
        int x=h[i];
        //printf("%.4f ",(db)K[x]);
        ldb k=K[x]; //notice that we should set K monotone decreasing.
        while(t<st-1 && SlopeBetter(s[t+1],s[t],k)) t++;
        d[x]=max(d[x],A[x]*s[t].x+B[x]*s[t].y);
        //printf("update %.4f %.4f for %d
",(db)s[t].x,(db)s[t].y,x);
    }
    //printf("end.
");
    
    DC(mid+1,r); //this will set queries in [mid+1,r] to correct ans.
    
    //set array p.
    //note that p is just for the next convex.
    //it's not what we're doing divide and conquar on.
    t=0;
    p1=l,p2=mid+1;
    while(p1<=mid && p2<=r)
    if(X[p[p1]]<X[p[p2]]) q[t++]=p[p1++]; else q[t++]=p[p2++];
    while(p1<=mid) q[t++]=p[p1++];
    while(p2<=r) q[t++]=p[p2++];
    memcpy(p+l,q,sizeof(int)*(r-l+1));
    
    //printf("[%d,%d] p(d):",l,r); for(int i=l;i<=r;i++) printf("%d ",p[i]); printf("
");
}


int n;

int main()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
    
    n=getint();
    d[1]=d[0]=getdb();
    
    for(int i=1;i<=n;i++)
        A[i]=getdb(),
        B[i]=getdb(),
        R[i]=getdb();
    
    for(int i=1;i<=n;i++)
    K[i]=-(A[i]/B[i]);
    
    for(int i=0;i<=n;i++)
    h[i]=p[i]=i;
    
    stable_sort(h+1,h+n+1,kcmp);
    
    //for(int i=1;i<=n;i++) printf("%d A:%2.4f B:%2.4f R:%2.4f K:%2.4f
",i,(db)A[i],(db)B[i],(db)R[i],(db)K[i]);
    //for(int i=1;i<=n;i++) printf("%d %.4f
",h[i],(db)K[h[i]]);
    
    DC(1,n);
    
    cout.precision(3);
    cout<<fixed;
    cout<<d[n]<<endl;
    
    //for(int i=1;i<=n;i++) printf("resault of %d is %.4f
",i,(db)d[i]);
    
    return 0;
}

/*
5 1.00
12 8 3
13 9 2
13 9 2
13 10 2
13 8 3
*/

对归并操作和凸壳维护太不熟了.........还有各种指针(包括保存下标的伪指针) o(╯□╰)o ......

听说有人被卡精度?于是我用了 long double ... 然而double也能A ......

不过BZOJ上的 long double 真的是12位=.=

还是把去掉注释的版本放上来吧.....

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

inline double getdb()
{ double x; scanf("%lf",&x); return x; }

struct point //also vector
{
    ldb x,y; point(){} point(ldb a,ldb b):x(a),y(b){}
    ldb operator*(point f) { return x*f.y-y*f.x; }
    point operator-(point f) { return point(x-f.x,y-f.y); }
    point operator()(point f) { return point(f.x-x,f.y-y); }
};

inline bool ConvexChange(point&a,point&s1,point&s2)
{ return s1(a)*s2(a)<=0.0; }

inline bool SlopeBetter(point&a,point&b,ldb k)
{ return a.y-b.y >= k*(a.x-b.x); }

bool cmpdec(const ldb&a,const ldb&b)
{ return a>=b; }

ldb d[105000];
ldb A[105000];
ldb B[105000];
ldb R[105000];

ldb X[105000];
ldb Y[105000];
ldb K[105000];
bool kcmp(const int&a,const int&b)
{ return K[a]>=K[b]; }

point s[105000]; int st;

int h[105000];
int q[105000];
int p[105000];
void DC(int l,int r)
{
    if(l==r)  
    {
        d[l]=max(d[l-1],d[l]);
        Y[l]=d[l]/(R[l]*A[l]+B[l]);
        X[l]=Y[l]*R[l];
        return ;
    }
    int mid=(l+r)>>1;
    
    int p1=l,p2=mid+1;
    for(int i=l;i<=r;i++)
    if(h[i]<=mid) q[p1++]=h[i]; else q[p2++]=h[i];
    memcpy(h+l,q+l,sizeof(int)*(r-l+1));
    
    DC(l,mid);
    
    st=0;
    s[st++]=point(0,0);
    for(int i=l;i<=mid;i++)
    {
        point c(X[p[i]],Y[p[i]]);
        while(st>1 && ConvexChange(c,s[st-1],s[st-2])) st--;
        s[st++]=c;
    }
    
    int t=0;
    for(int i=mid+1;i<=r;i++)
    {
        int x=h[i];
        ldb k=K[x];
        while(t<st-1 && SlopeBetter(s[t+1],s[t],k)) t++;
        d[x]=max(d[x],A[x]*s[t].x+B[x]*s[t].y);
    }
    
    DC(mid+1,r);
    
    t=0,p1=l,p2=mid+1;
    while(p1<=mid && p2<=r)
    if(X[p[p1]]<X[p[p2]]) q[t++]=p[p1++]; else q[t++]=p[p2++];
    while(p1<=mid) q[t++]=p[p1++];
    while(p2<=r) q[t++]=p[p2++];
    memcpy(p+l,q,sizeof(int)*(r-l+1));
}

int n;

int main()
{
    n=getint();
    d[1]=d[0]=getdb();
    
    for(int i=1;i<=n;i++)
        A[i]=getdb(),
        B[i]=getdb(),
        R[i]=getdb();
    
    for(int i=1;i<=n;i++)
    K[i]=-(A[i]/B[i]);
    
    for(int i=0;i<=n;i++)
    h[i]=p[i]=i;
    
    stable_sort(h+1,h+n+1,kcmp);
    
    DC(1,n);
    
    cout.precision(3);
    cout<<fixed;
    cout<<d[n]<<endl;
    
    return 0;
}

用 long double 只比 double 慢了总共 88ms ...

...