SCOI2010 序列操作

2421 序列操作

http://codevs.cn/problem/2421/

2010年省队选拔赛四川

题目描述 Description

lxhgww最近收到了一个01序列，序列里面包含了n个数，这些数要么是0，要么是1，现在对于这个序列有五种变换操作和询问操作：

0 a b 把[a, b]区间内的所有数全变成0

1 a b 把[a, b]区间内的所有数全变成1

2 a b 把[a,b]区间内的所有数全部取反，也就是说把所有的0变成1，把所有的1变成0

3 a b 询问[a, b]区间内总共有多少个1

4 a b 询问[a, b]区间内最多有多少个连续的1

对于每一种询问操作，lxhgww都需要给出回答，聪明的程序员们，你们能帮助他吗？

输入描述 Input Description

输入数据第一行包括2个数，n和m，分别表示序列的长度和操作数目

第二行包括n个数，表示序列的初始状态

接下来m行，每行3个数，op, a, b，（0<=op<=4，0<=a<=b<n）表示对于区间[a, b]执行标号为op的操作

输出描述 Output Description

对于每一个询问操作，输出一行，包括1个数，表示其对应的答案

样例输入 Sample Input

10 10

0 0 0 1 1 0 1 0 1 1

1 0 2

3 0 5

2 2 2

4 0 4

0 3 6

2 3 7

4 2 8

1 0 5

0 5 6

3 3 9

样例输出 Sample Output

数据范围及提示 Data Size & Hint

对于30%的数据，1<=n, m<=1000

对于100%的数据，1<=n, m<=100000

线段树

题目AC四步走

第一步：TLE 50分

代码中线段树均使用2n空间方法建树

维护信息：

0的个数sum_0，1的个数sum_1, 连续的0的个数con_0, 连续的1的个数con_1;
左端点连续0的个数l_0, 右端点连续0的个数r_0, 左端点连续1的个数l_1, 右端点连续1的个数r_1;
懒标记f，f=-1表示区间无标记，=0表示区间有一个全部更新为0的标记没有下穿，=1同理;

操作0,1：线段树基本的区间修改

操作2：可以一直递归到一个区间都是0或都是1时在操作，也相当于区间修改

操作3：线段树基本的区间查询

操作4：类似于求GSS的查询过程，在更新l_0,r_0，l_1,r_1时稍有不同，要先判断是否包括整个左右子区间

TLE 原因:多余的标记下传

1、标记下穿时，没有必要保证子节点的标记也下传了，因为有效标记只有两种，0，1，而且是对整个区间完全覆盖，所以多个标记只有最后一个有效

2、区间取反时，没有必要保证本区间标记下传，因为如果原来区间标记是0，意思是子区间要变为0，区间取反后区间标记是1，意思是子区间要变为1，与原来标记是什么无关。

第二步：AC 100分，总时间耗费: 881ms 总内存耗费: 11 MB

将导致TLE的3行删去

#include<cstdio>

#include<algorithm>

using namespace std;

struct node

{

    int l,r;

    int sum_0,sum_1,con_0,con_1,sum;

    int l_0,r_0,l_1,r_1;

    int f;

}e[];

int n,m,cnt,x,p,a,b,anss;

void change(int,int);

inline void up(int k)

{

    int l=k+,r=k+e[k+].sum*;

    e[k].sum_0=e[l].sum_0+e[r].sum_0;

    e[k].sum_1=e[l].sum_1+e[r].sum_1;

    e[k].con_0=max(max(e[l].con_0,e[r].con_0),e[l].r_0+e[r].l_0);

    e[k].con_1=max(max(e[l].con_1,e[r].con_1),e[l].r_1+e[r].l_1);

    if(e[l].con_0==e[l].sum) e[k].l_0=e[l].sum+e[r].l_0;

    else e[k].l_0=e[l].l_0;

    if(e[r].con_0==e[r].sum) e[k].r_0=e[r].sum+e[l].r_0;

    else e[k].r_0=e[r].r_0;

    if(e[l].con_1==e[l].sum) e[k].l_1=e[l].sum+e[r].l_1;

    else e[k].l_1=e[l].l_1;

    if(e[r].con_1==e[r].sum) e[k].r_1=e[r].sum+e[l].r_1;

    else e[k].r_1=e[r].r_1;

}

inline void all_0(int k)

{

    e[k].sum_0=e[k].con_0=e[k].l_0=e[k].r_0=e[k].sum;

    e[k].sum_1=e[k].con_1=e[k].l_1=e[k].r_1=;

}

inline void all_1(int k)

{

    e[k].sum_1=e[k].con_1=e[k].l_1=e[k].r_1=e[k].sum;

    e[k].sum_0=e[k].con_0=e[k].l_0=e[k].r_0=;

}

inline void down(int k)

{

    if(e[k].l==e[k].r) return;

    int l=k+,r=k+e[k+].sum*;

    //if(e[l].f!=-1) down(l); TLE

    //if(e[r].f!=-1) down(r); TLE

    if(!e[k].f)

    {

        all_0(l);all_0(r);

        e[l].f=e[r].f=;

    }

    else

    {

        all_1(l);all_1(r);

        e[l].f=e[r].f=;

    }

    e[k].f=-;

}

inline void judge(int k)

{

    //if(e[k].f!=-1) down(k); TLE

    if(e[k].sum_0==e[k].sum)

    {

        all_1(k);

        e[k].f=;

    }

    else if(e[k].sum_1==e[k].sum)

    {

        all_0(k);

        e[k].f=;

    }

    else

    {

        judge(k+);

        judge(k+e[k+].sum*);

    }

    if(e[k].f!=-) down(k);

    if(e[k].l!=e[k].r) up(k);

}

inline void change(int k,int g)

{

    if(e[k].l>=a&&e[k].r<=b)

    {

        if(!g)        { all_0(k); e[k].f=; }

        else if(g==) { all_1(k); e[k].f=; }

        else if(g==) { judge(k); }

        else if(g==) { anss+=e[k].sum_1; }

        return;

    }

    if(e[k].f!=-) down(k);

    int mid=e[k].l+e[k].r>>;

    if(a<=mid) change(k+,g);

    if(b>mid) change(k+e[k+].sum*,g);

    up(k);

}

inline void build(int l,int r)

{

    cnt++;

    int h=cnt;

    e[cnt].l=l;e[cnt].r=r;

    e[cnt].sum=r-l+;

    e[cnt].f=-;

    if(l==r)

    {

        scanf("%d",&x);

        if(x) { e[cnt].sum_1=e[cnt].con_1=e[cnt].l_1=e[cnt].r_1=; }

        else  { e[cnt].sum_0=e[cnt].con_0=e[cnt].l_0=e[cnt].r_0=; }

        return;

    }

    int mid=l+r>>;

    build(l,mid);build(mid+,r);

    up(h);

}

inline void ask(int k,int & ans,int & ans_l,int & ans_r)

{

    int l=k+,r=k+e[k+].sum*;

    if(e[k].l>=a&&e[k].r<=b)

    {

        ans=e[k].con_1;

        ans_l=e[k].l_1;

        ans_r=e[k].r_1;

        return;

    }

    if(e[k].f!=-) down(k);

    int mid=e[k].l+e[k].r>>;

    if(b<=mid) ask(l,ans,ans_l,ans_r);

    else if(a>mid) ask(r,ans,ans_l,ans_r);

    else

    {

        int lch_ans,lch_l_1,lch_r_1,rch_ans,rch_l_1,rch_r_1;

        ask(l,lch_ans,lch_l_1,lch_r_1);

        ask(r,rch_ans,rch_l_1,rch_r_1);

        ans=max(lch_ans,rch_ans);

        ans=max(ans,lch_r_1+rch_l_1);

        if(e[l].con_1==e[l].sum) ans_l=max(lch_l_1,e[l].sum+rch_l_1);

        else ans_l=lch_l_1;

        if(e[r].con_1==e[r].sum) ans_r=max(rch_r_1,e[r].sum+lch_r_1);

        else ans_r=rch_r_1;

    }

}

int main()

{

    scanf("%d%d",&n,&m);

    build(,n-);

    int ans,ans_l,ans_r;

    for(int i=;i<=m;i++)

    {

        scanf("%d%d%d",&p,&a,&b);

        switch(p)

        {

            case :change(,);break;

            case :change(,);break;

            case :change(,);break;

            case :anss=,change(,),printf("%d\n",anss);break;

            case :ask(,ans,ans_l,ans_r),printf("%d\n",ans);

        }

    }

}

第三步：去掉多余信息总时间耗费: 683ms 总内存耗费: 6 MB

老师讲课时提到要维护0的信息，是因为操作2可以直接交换0和1的信息来完成

但自己做的时候操作2不是这样实现的，所以0的信息不用维护

#include<cstdio>

#include<algorithm>

using namespace std;

struct node

{

    int l,r;

    int sum_1,con_1,sum;

    int l_1,r_1;

    int f;

}e[];

int n,m,cnt,x,p,a,b,anss;

void change(int,int);

inline void up(int k)

{

    int l=k+,r=k+e[k+].sum*;

    e[k].sum_1=e[l].sum_1+e[r].sum_1;

    e[k].con_1=max(max(e[l].con_1,e[r].con_1),e[l].r_1+e[r].l_1);

    if(e[l].con_1==e[l].sum) e[k].l_1=e[l].sum+e[r].l_1;

    else e[k].l_1=e[l].l_1;

    if(e[r].con_1==e[r].sum) e[k].r_1=e[r].sum+e[l].r_1;

    else e[k].r_1=e[r].r_1;

}

inline void all_0(int k)

{

    e[k].sum_1=e[k].con_1=e[k].l_1=e[k].r_1=;

}

inline void all_1(int k)

{

    e[k].sum_1=e[k].con_1=e[k].l_1=e[k].r_1=e[k].sum;

}

inline void down(int k)

{

    if(e[k].l==e[k].r) return;

    int l=k+,r=k+e[k+].sum*;

    if(!e[k].f)

    {

        all_0(l);all_0(r);

        e[l].f=e[r].f=;

    }

    else

    {

        all_1(l);all_1(r);

        e[l].f=e[r].f=;

    }

    e[k].f=-;

}

inline void judge(int k)

{

    if(!e[k].sum_1)

    {

        all_1(k);

        e[k].f=;

    }

    else if(e[k].sum_1==e[k].sum)

    {

        all_0(k);

        e[k].f=;

    }

    else

    {

        judge(k+);

        judge(k+e[k+].sum*);

    }

    if(e[k].f!=-) down(k);

    if(e[k].l!=e[k].r) up(k);

}

inline void change(int k,int g)

{

    if(e[k].l>=a&&e[k].r<=b)

    {

        if(!g)        { all_0(k); e[k].f=; }

        else if(g==) { all_1(k); e[k].f=; }

        else if(g==) { judge(k); }

        else if(g==) { anss+=e[k].sum_1; }

        return;

    }

    if(e[k].f!=-) down(k);

    int mid=e[k].l+e[k].r>>;

    if(a<=mid) change(k+,g);

    if(b>mid) change(k+e[k+].sum*,g);

    up(k);

}

inline void build(int l,int r)

{

    cnt++;

    int h=cnt;

    e[cnt].l=l;e[cnt].r=r;

    e[cnt].sum=r-l+;

    e[cnt].f=-;

    if(l==r)

    {

        scanf("%d",&x);

        if(x) { e[cnt].sum_1=e[cnt].con_1=e[cnt].l_1=e[cnt].r_1=; }

        return;

    }

    int mid=l+r>>;

    build(l,mid);build(mid+,r);

    up(h);

}

inline void ask(int k,int & ans,int & ans_l,int & ans_r)

{

    int l=k+,r=k+e[k+].sum*;

    if(e[k].l>=a&&e[k].r<=b)

    {

        ans=e[k].con_1;

        ans_l=e[k].l_1;

        ans_r=e[k].r_1;

        return;

    }

    if(e[k].f!=-) down(k);

    int mid=e[k].l+e[k].r>>;

    if(b<=mid) ask(l,ans,ans_l,ans_r);

    else if(a>mid) ask(r,ans,ans_l,ans_r);

    else

    {

        int lch_ans,lch_l_1,lch_r_1,rch_ans,rch_l_1,rch_r_1;

        ask(l,lch_ans,lch_l_1,lch_r_1);

        ask(r,rch_ans,rch_l_1,rch_r_1);

        ans=max(lch_ans,rch_ans);

        ans=max(ans,lch_r_1+rch_l_1);

        if(e[l].con_1==e[l].sum) ans_l=max(lch_l_1,e[l].sum+rch_l_1);

        else ans_l=lch_l_1;

        if(e[r].con_1==e[r].sum) ans_r=max(rch_r_1,e[r].sum+lch_r_1);

        else ans_r=rch_r_1;

    }

}

int main()

{

    scanf("%d%d",&n,&m);

    build(,n-);

    int ans,ans_l,ans_r;

    for(int i=;i<=m;i++)

    {

        scanf("%d%d%d",&p,&a,&b);

        switch(p)

        {

            case :change(,);break;

            case :change(,);break;

            case :change(,);break;

            case :anss=,change(,),printf("%d\n",anss);break;

            case :ask(,ans,ans_l,ans_r),printf("%d\n",ans);

        }

    }

}

第四步：换方法操作2按上面说的实现

然而代码越改越长，空间越勇越大，时间越用越多，却并没有AC

这道题耗了1天了，时间不允许了，日后再改吧

#include<cstdio>

#include<algorithm>

using namespace std;

struct node

{

    int l,r;

    int sum_0,sum_1,con_0,con_1,sum;

    int l_0,r_0,l_1,r_1;

    int f;

    bool f2;

}e[];

int n,m,cnt,x,p,a,b,anss;

void change(int,int);

inline void up(int k)

{

    int l=k+,r=k+e[k+].sum*;

    e[k].sum_0=e[l].sum_0+e[r].sum_0;

    e[k].sum_1=e[l].sum_1+e[r].sum_1;

    e[k].con_0=max(max(e[l].con_0,e[r].con_0),e[l].r_0+e[r].l_0);

    e[k].con_1=max(max(e[l].con_1,e[r].con_1),e[l].r_1+e[r].l_1);

    if(e[l].con_0==e[l].sum) e[k].l_0=e[l].sum+e[r].l_0;

    else e[k].l_0=e[l].l_0;

    if(e[r].con_0==e[r].sum) e[k].r_0=e[r].sum+e[l].r_0;

    else e[k].r_0=e[r].r_0;

    if(e[l].con_1==e[l].sum) e[k].l_1=e[l].sum+e[r].l_1;

    else e[k].l_1=e[l].l_1;

    if(e[r].con_1==e[r].sum) e[k].r_1=e[r].sum+e[l].r_1;

    else e[k].r_1=e[r].r_1;

}

inline void all_0(int k)

{

    e[k].sum_0=e[k].con_0=e[k].l_0=e[k].r_0=e[k].sum;

    e[k].sum_1=e[k].con_1=e[k].l_1=e[k].r_1=;

}

inline void all_1(int k)

{

    e[k].sum_1=e[k].con_1=e[k].l_1=e[k].r_1=e[k].sum;

    e[k].sum_0=e[k].con_0=e[k].l_0=e[k].r_0=;

}

inline void judge(int k)

{

    swap(e[k].con_0,e[k].con_1);

    swap(e[k].sum_0,e[k].sum_1);

    swap(e[k].l_0,e[k].l_1);

    swap(e[k].r_0,e[k].r_1);

    if(e[k].l!=e[k].r) {e[k].f=;e[k].f2=true;}

}

void ww(int l)

{

        if(e[l].l==e[l].r) judge(l);

        else if(e[l].f==) {e[l].f=;e[l].f2=false;}

        else if(e[l].f==) {e[l].f=;e[l].f2=false;}

        else if(e[l].f==) e[l].f=-;

        else                judge(l);

}

inline void down(int k)

{

    if(e[k].l==e[k].r) return;

    int l=k+,r=k+e[k+].sum*;

    if(!e[k].f)

    {

        all_0(l);all_0(r);

        if(e[l].l!=e[l].r)

        {

            e[l].f=e[r].f=;

            e[l].f2=e[r].f2=true;

        }

    }

    else if(e[k].f==)

    {

        all_1(l);all_1(r);

        if(e[k].l!=e[k].r)

        {

            e[l].f=e[r].f=;

            e[r].f2=e[l].f2=true;

        }

    }

    else

    {

        ww(l);

        ww(r);

        if(e[k].l!=e[k].r) up(k);

    }

    e[k].f=-;

}

inline int mm(int k)

{

    if(e[k].f==-) return e[k].sum_1;

    if(e[k].f2==true) return e[k].sum_1;

    if(e[k].f==) return ;

    if(e[k].f==) return e[k].sum;

    if(e[k].f==) return e[k].sum_0;

}

inline void change(int k,int g)

{

    if(e[k].l>=a&&e[k].r<=b)

    {

        if(!g)

        {

            all_0(k);

            if(e[k].l!=e[k].r)  e[k].f=;

        }

        else if(g==)

        {

            all_1(k);

            if(e[k].l!=e[k].r) e[k].f=;

        }

        else if(g==) { ww(k); }

        else if(g==) { anss+=mm(k); }

        return;

    }

    if(e[k].f!=-) down(k);

    int mid=e[k].l+e[k].r>>;

    if(a<=mid) change(k+,g);

    if(b>mid) change(k+e[k+].sum*,g);

    up(k);

}

inline void build(int l,int r)

{

    cnt++;

    int h=cnt;

    e[cnt].l=l;e[cnt].r=r;

    e[cnt].sum=r-l+;

    e[cnt].f=-;

    e[cnt].f2=true;

    if(l==r)

    {

        scanf("%d",&x);

        if(x) { e[cnt].sum_1=e[cnt].con_1=e[cnt].l_1=e[cnt].r_1=; }

        else { e[cnt].sum_0=e[cnt].con_0=e[cnt].l_0=e[cnt].r_0=; }

        return;

    }

    int mid=l+r>>;

    build(l,mid);build(mid+,r);

    up(h);

}

inline void ask(int k,int & ans,int & ans_l,int & ans_r)

{

    int l=k+,r=k+e[k+].sum*;

    if(e[k].l>=a&&e[k].r<=b)

    {

        if(e[k].f2==true)

        {

            ans=e[k].con_1;

            ans_l=e[k].l_1;

            ans_r=e[k].r_1;

        }

        else

        {

            ans=e[k].con_0;

            ans_l=e[k].l_0;

            ans_r=e[k].r_0;

        }

        return;

    }

    if(e[k].f!=-) down(k);

    int mid=e[k].l+e[k].r>>;

    if(b<=mid) ask(l,ans,ans_l,ans_r);

    else if(a>mid) ask(r,ans,ans_l,ans_r);

    else

    {

        int lch_ans,lch_l_1,lch_r_1,rch_ans,rch_l_1,rch_r_1;

        ask(l,lch_ans,lch_l_1,lch_r_1);

        ask(r,rch_ans,rch_l_1,rch_r_1);

        ans=max(lch_ans,rch_ans);

        ans=max(ans,lch_r_1+rch_l_1);

        if(e[l].con_1==e[l].sum) ans_l=max(lch_l_1,e[l].sum+rch_l_1);

        else ans_l=lch_l_1;

        if(e[r].con_1==e[r].sum) ans_r=max(rch_r_1,e[r].sum+lch_r_1);

        else ans_r=rch_r_1;

    }

}

int main()

{

    scanf("%d%d",&n,&m);

    build(,n-);

    int ans,ans_l,ans_r;

    for(int i=;i<=m;i++)

    {

        scanf("%d%d%d",&p,&a,&b);

        switch(p)

        {

            case :change(,);break;

            case :change(,);break;

            case :change(,);break;

            case :anss=,change(,),printf("%d\n",anss);break;

            case :ask(,ans,ans_l,ans_r),printf("%d\n",ans);

        }

    }

}

错误代码

第一步中出现的错误

1、第一次提交RE

2、第二次提交10分，找出RE的错误：down函数里区间标记下传时，没有判断是否到了叶子节点。因为2*n的空间建树，没有节点浪费，但也没有了多余的节点，4*空间建树可以不用判断

3、第三次提交10分，找出部分错误：down函数里区间标记下传时，只更改了子区间的0,1信息，忘了更改懒标记

4、第四次提交TLE50分，找出所有错误：judge函数区间取反时，

①没有在每次取反后标记下传，

如果本区间全是0或1，当然要下传标记。

如果本区间不全是0或1，那区间没有标记，就不需要下穿，又因为没有标记是-1，下传会导致错误，所以 ③要先判断是否需要下传标记

②没有对区间修改后的区间信息合并，线段树的修改操作改完要合并信息，又因为2*n的空间建树，所以要 ④先判断是否是叶子节点再合并。change函数里不需要判断叶子节点，是因为到达的叶子节点一定属于操作区间，在合并之前会return

第四步做了一上午，交了10遍，全是10分，放弃，O|￣|_

错误全部集中在down、和取反两个函数里，而down函数只写过求和和最大值的标记，取反函数第一次写，其余函数以前写过，没有错误

SCOI2010 序列操作的更多相关文章

bzoj 1858: [Scoi2010]序列操作
1858: [Scoi2010]序列操作 Time Limit: 10 Sec Memory Limit: 64 MB 线段树,对于每个区间需要分别维护左右和中间的1和0连续个数,并在op=4时特殊 ...
BZOJ 1858: [Scoi2010]序列操作( 线段树 )
略恶心的线段树...不过只要弄清楚了AC应该不难.... ---------------------------------------------------------------- #inclu ...
bzoj1858[Scoi2010]序列操作线段树
1858: [Scoi2010]序列操作 Time Limit: 10 Sec Memory Limit: 64 MBSubmit: 3079 Solved: 1475[Submit][Statu ...
BZOJ_1858_[Scoi2010]序列操作_线段树
BZOJ_1858_[Scoi2010]序列操作_线段树 Description lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要么是1,现在对于这个序列有五种变换操作和询 ...
【题解】Luogu P2572 [SCOI2010]序列操作
原题传送门:P2572 [SCOI2010]序列操作这题好弱智啊裸的珂朵莉树前置芝士:珂朵莉树窝博客里对珂朵莉树的介绍没什么好说的自己看看吧操作1:把区间内所有数推平成0,珂朵莉树基本操作 ...
P2572 [SCOI2010]序列操作
对自己 & $RNG$ : 骄兵必败 $lpl$加油! P2572 [SCOI2010]序列操作题目描述 lxhgww最近收到了一个01序列,序列里面包含了n个数,这些数要么是0,要 ...
BZOJ1858 [Scoi2010]序列操作（线段树）
题目链接 [Scoi2010]序列操作考验代码能力的一道好题. 思想还是很简单的(直接上线段树),但是比较难写. #include <bits/stdc++.h> using names ...
(WAWAWAWAWAWA) BZOJ 1858: [Scoi2010]序列操作
二次联通门 : BZOJ 1858: [Scoi2010]序列操作 /* BZOJ 1858: [Scoi2010]序列操作已经... 没有什么好怕的的了... 16K的代码... 调个MMP啊.. ...
1858: [Scoi2010]序列操作
1858: [Scoi2010]序列操作 Time Limit: 10 Sec Memory Limit: 64 MB Submit: 3397 Solved: 1624 [Submit][Statu ...

随机推荐

模拟退火小结(Bzoj3680：吊打xxx)
简介就是模拟退火的物理过程,每次随机逼近乘上温度,以$e^{\Delta/T}$的概率接受答案,随机一个概率比较然后就是调参+乱搞题目 Bzoj3680:吊打xxx 代码 # include ...
[BZOJ3751] [NOIP2014] 解方程 (数学)
Description 已知多项式方程:$a_0+a_1*x+a_2*x^2+...+a_n*x^n=0$ 求这个方程在[1,m]内的整数解(n和m均为正整数). Input 第一行包含2个整数n.m ...
【linux之软件安装，rpm，yum】
一.软件管理静态库动态库静态库:在程序编译时会被连接到目标代码中,程序运行时将不再需要该静态库动态库:在程序编译时并不会被连接到目标代码中,而是在程序运行时才被载入. 链接是程序调用库的过程. 静 ...
Python 终端输出字体颜色
终端的字符颜色是用转义序列控制的,是文本模式下的系统显示功能,和具体的语言无关. 转义序列是以ESC开头,即用\033来完成(ESC的ASCII码用十进制表示是27,用八进制表 ...
Django Middleware简介
1 前言 Django使用非常熟练了,各种API接口不在话下,全都搞定.为方便定位问题在每个API接口的的开始和返回的地方都加上了log打印,记录入参和返回值. 但是这样有一个问题,需要每个 ...
angular路由详解三（路由参数传递）
我们经常用路由传递参数,路由主要有三种方式: 第一种:在查询参数中传递数据 {path:"address/:id"} => address/1 => Activa ...
mybatis——分页插件
1.引入依赖的jar 2.在mybatis的配置文件中注册该插件(如果不注册,PageInfo永远为NULL) 3.使用分页插件
JavaScript之优化DOM
优化DOM得从重绘和重排讲起,long long ago... 1.重绘和重排 1.1 重绘和重排是什么重绘是指一些样式的修改,元素的位置和大小都没有改变: 重排是指元素的位置或尺寸发生了变化,浏览 ...
使用IIS Server Farms搭建应用服务负载均衡
当公司的业务扩大, 伴随着大量的请求,应用服务器的承受能力已经不能满足不断增长的业务需求,使用IIS Server Farms搭建应负载均衡的方式,把请求分发给不同的应用服务器进行处理,这个时候就降低 ...
C语言与C++语言之间关系
很多时候我们对于C和C++的区别不是很清楚,以至于弄混的情况并不少见.那C语言和C++语言到底是怎么回事呢? 首先,我们来看下百度百科对语言和C++语言描述,相对而说也还算是比较权威的. C语言 C语 ...

SCOI2010 序列操作

2421 序列操作

SCOI2010 序列操作的更多相关文章

随机推荐

热门专题