Gitfan
Gitfan

线段树

http://blog.csdn.net/liuledidai/article/details/9964697

( 1 )线段树功能: 单点替换 区间最值
I Hate It

#include 
#include 
using namespace std;
#define lson l , m , rt << 1
#define rson m + 1 , r , rt << 1 | 1
const int maxn = 222222;
int MAX[maxn<<2];
void PushUP(int rt) {
MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);
}
void build(int l,int r,int rt) {  //rt当前节点编号
    if (l == r)//l==r,说明rt节点是叶子节点
    {           //由于先build左子树,再build右子树,所以最终会先写完左边的叶子节点,再写完右边的叶子节点
        scanf("%d",&MAX[rt]);
        return ;
    }
    int m = (l + r) >> 1;
    build(l , m , rt << 1);//rt*2
    build(m + 1 , r , rt << 1 | 1);//rt*2+1( rt*2 是偶数,rt<<1|1=rt*2+1)
    PushUP(rt);
}
void update(int p,int sc,int l,int r,int rt)
{
    if (l == r) {
        MAX[rt] = sc;
        return ;
    }
    int m = (l + r) >> 1;
    if (p <= m) update(p , sc , l , m , rt << 1);
    else update(p , sc , m + 1 , r , rt << 1 | 1);
    //PushUP(rt);
     MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);
}
int query(int L,int R,int l,int r,int rt)//l r为线段树的完美区间,l mid为左子树区间, mid+1,r为右子树区间
{                                        //L , R是当前查询区间,它可能不是完美的,有可能包含左子树区间的一部分或者右子树的一部分
    if(L==l&&R==r) return MAX[rt];
    int m = (l + r) >> 1;
    int ret = 0;
    if(m>=R) return query(L,R,l,m,rt<<1);
    else if(m+1<=L) return query(L,R,m+1,r,rt<<1|1);
    else return max(query(L,m,l,m,rt<<1),query(m+1,R,m+1,r,rt<<1|1));
}
int main() {
    int n , m;
    while (~scanf("%d%d",&n,&m)) {
        build(1 , n , 1);
        while (m --) {
            char op[2];
            int a , b;
            scanf("%s%d%d",op,&a,&b);
            if (op[0] == 'Q') printf("%d\n",query(a , b , 1 , n , 1));
            else update(a , b , 1 , n , 1);
        }
    }
    return 0;
}

（ 2）线段树功能:update:单点增减 query:区间求和
敌兵布阵

#include 
#include 
#include
#define mid ((l+r)>>1)
using namespace std;
const int MAXN=50010;
int sum[MAXN<<2];
void build(int l,int r,int rt)
{
    if(l==r)
    {
        scanf("%d",&sum[rt]);
        return;
    }
    build(l,mid,rt<<1);
    build(mid+1,r,rt<<1|1);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void update(int pos,int val,int l,int r,int rt)
{
    if(l==r)
    {
        sum[rt]+=val;
        return;
    }
    if(pos<=mid) update(pos,val,l,mid,rt<<1);
    else update(pos,val,mid+1,r,rt<<1|1);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
int query(int L,int R,int l,int r,int rt)
{
    if(L==l&&R==r) return sum[rt];
    if(R<=mid) return query(L,R,l,mid,rt<<1);
    else if(mid+1<=L) return query(L,R,mid+1,r,rt<<1|1);
    else return query(L,mid,l,mid,rt<<1)+query(mid+1,R,mid+1,r,rt<<1|1);
}
int main()
{
    int t,n,L,R,val,pos;
    char order[10];
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++)
    {
        scanf("%d",&n);
        build(1,n,1);
        printf("Case %d:\n",cas);
        while(true)
        {
            scanf("%s",order);
            if(strcmp(order,"End")==0) break;
            else if(strcmp(order,"Query")==0)
            {
                scanf("%d%d",&L,&R);
                printf("%d\n",query(L,R,1,n,1));
            }
            else if(strcmp(order,"Add")==0)
            {
                scanf("%d%d",&pos,&val);
                update(pos,val,1,n,1);
            }
            else
            {
                scanf("%d%d",&pos,&val);
                update(pos,-val,1,n,1);
            }
        }
    }
    return 0;
}

求逆序数+离散化
（ 3 ）线段树功能:update:单点增减 query:区间求和
参考文档
Ultra-QuickSort
题意:
求解一个序列的逆序数

#include 
#include
#include
#include 
#define maxn  500010
using namespace std;
int segTree[maxn<<2],aa[maxn];
struct Node
{
    int val,id;
}arr[maxn];
int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return segTree[rt];
    int mid=(l+r)>>1;
    int ret=0;
    if(L<=mid) ret+=query(L,R,l,mid,rt<<1);
    if(R>=mid+1) ret+=query(L,R,mid+1,r,(rt<<1)|1);
    return ret;
}
void update(int index,int l,int r,int rt)
{
    if(l==r)
    {
        segTree[rt]++;
        return;

    }
    int mid=(l+r)>>1;
    if(index<=mid) update(index,l,mid,rt<<1);
    else update(index,mid+1,r,(rt<<1)|1);
    segTree[rt]=segTree[rt<<1]+segTree[(rt<<1)|1];
}
int cmp(const void *a,const void * b)
{
    return (*(Node *)a).val-(*(Node *)b).val;
}
int main() {
    int n,i;
    while(scanf("%d",&n)!=EOF,n)
    {
        memset(segTree,0,sizeof(segTree));
        for(i=1;i<=n;i++)
        {
            scanf("%d",&arr[i].val);
            arr[i].id=i;
        }
        qsort(arr+1,n,sizeof(Node),cmp);
        for(int i=1;i<=n;i++)
            aa[arr[i].id]=i;
        long long  sum=0;
        for(int i=1;i<=n;i++)
        {
            sum+=query(aa[i],n,1,n,1);
            update(aa[i],1,n,1);
        }
        printf("%lld\n",sum);
    }

}

Minimum Inversion Number

#include 
#include
#include
#include 
#define maxn  5005
using namespace std;
int segTree[maxn<<2],arr[maxn];
int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return segTree[rt];
    int mid=(l+r)>>1;
    int ret=0;
    if(L<=mid) ret+=query(L,R,l,mid,rt<<1);
    if(R>=mid+1) ret+=query(L,R,mid+1,r,(rt<<1)|1);
    return ret;
}
void update(int index,int l,int r,int rt)
{
    if(l==r)
    {
        segTree[rt]++;
        return;

    }
    int mid=(l+r)>>1;
    if(index<=mid) update(index,l,mid,rt<<1);
    else update(index,mid+1,r,(rt<<1)|1);
    segTree[rt]=segTree[rt<<1]+segTree[(rt<<1)|1];
}
int main() {
    int n,i;
    while(scanf("%d",&n)!=EOF)
    {
        memset(segTree,0,sizeof(segTree));
        for(i=1;i<=n;i++)
        {
            scanf("%d",&arr[i]);
        }
        int  sum=0;
        for(int i=1;i<=n;i++)
        {
            sum+=query(arr[i],n-1,0,n-1,1);
            update(arr[i],0,n-1,1);
        }
        int ret=sum;
        for(int i=1;i<=n;i++)
        {
            sum+=n-arr[i]-arr[i]-1;
            ret=min(sum,ret);
        }
        printf("%lld\n",ret);
    }
}

( 4 ) 题意:h*w的木板,放进一些1*L的物品,求每次放空间能容纳且最上边的位子
思路:每次找到最大值的位子,然后减去L
线段树功能:query:区间求最大值的位子(直接把update的操作在query里做了)

把每行看成线段树的叶子记录每片叶子的剩余空间,而根节点中保存的是叶子节点最大的剩余空间,每次判断给定的宽度从根节点能否插入,若左子数可以插则优先插入左子树,这样就可以保证每次插入都插在最上面。

Billboard

#include 
#include
#include
#include 
#define maxn  900010
using namespace std;
int segTree[maxn],w,h,n;
void build(int l,int r,int rt)
{
    segTree[rt]=w;
    if(l==r) return;
    int mid=(l+r)>>1;
    build(l,mid,rt<<1);
    build(mid+1,r,rt<<1|1);
}
int query(int need,int l,int r,int rt)
{
    if(l==r)
    {
        segTree[rt]-=need;
        return l;
    }
    int ans,mid=(l+r)>>1;
    if(segTree[rt<<1]>=need) ans=query(need,l,mid,rt<<1);
    else ans=query(need,mid+1,r,rt<<1|1);
    segTree[rt]=max(segTree[rt<<1],segTree[rt<<1|1]);
    return ans;
}
int main() {
    int i,need;
    while(scanf("%d%d%d",&h,&w,&n)!=EOF)
    {
        h=min(h,n);
        build(1,h,1);
        for(i=1;i<=n;i++)
        {
            scanf("%d",&need);
            if(segTree[1]

https://scut.online/problem.php?id=77
( 5 ) 题意：有两个操作：
1、将区间[ L,R ]里的所有数变为原来的一半。
2、询问区间 [ L,R ]的数之和，结果对1000000007取模。
n,m(n,m≤100000），n为点的个数，编号为1-n，m为操作次数
线段树功能：区间更新，区间求和。注意一个可以优化的地方：在query和update操作中，如果segTree[rt]==0，则不必递归下去了；不然容易超时。

#include
#include 
using namespace std;
#define maxn 100010
typedef long long LL;
LL segTree[maxn<<2];
const LL mod=1000000007;
//void pushUp(int rt)
//{
//    segTree[rt]=(segTree[rt<<1]+segTree[(rt<<1)|1])%mod;
//}
void build(int l,int r,int rt)
{
    if(l==r)
    {
        scanf("%lld",&segTree[rt]);
        return;
    }
    int mid=l+((r-l)>>1);
    build(l,mid,rt<<1);
    build(mid+1,r,(rt<<1)|1);
    segTree[rt]=(segTree[rt<<1]+segTree[(rt<<1)|1])%mod;
}
LL query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R) return segTree[rt];
    if(L<=l&&r<=R&&segTree[rt]==0) return 0;
    int mid=l+((r-l)>>1);
    LL sum=0;
    if(mid>=L) sum=(sum+query(L,R,l,mid,rt<<1))%mod;
    if(mid+1<=R) sum=(sum+query(L,R,mid+1,r,(rt<<1)|1))%mod;
    return sum;
}
void update(int L,int R,int l,int r,int rt)
{
    if(l==r)
    {
        segTree[rt]>>=1;
        return;
    }
    if(L<=l&&r<=R&&segTree[rt]==0) return;
    int mid=l+((r-l)>>1);
    if(L<=mid) update(L,R,l,mid,rt<<1);
    if(mid+1<=R) update(L,R,mid+1,r,(rt<<1)|1);
    segTree[rt]=(segTree[rt<<1]+segTree[(rt<<1)|1])%mod;
}
int main()
{
    int t,L,R;
    char op[5];
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        build(1,n,1);
        for(int i=1;i<=m;i++)
        {
            scanf("%s%d%d",op,&L,&R);
            if(op[0]=='A')
            {
                printf("%lld\n",query(L,R,1,n,1));
            }
            else
            {
                update(L,R,1,n,1);
            }
        }
    }
}

( 6 ) 线段树功能：update :区间增减 query:区间求和
题目大意：给定N个数的序列，有Q个操作。
操作分两种：
1、将某个区间内的所有数都加上某个数。
2、计算某个区间的所有数之和并输出。

方法一:逐点更新

我们有一个朴素的思路,更新区间时对区间内的所有点逐个更新

#include 
#include 
#include
#define mid ((l+r)>>1)
using namespace std;
const int MAXN=100010;
long long sum[MAXN<<2];
void build(int l,int r,int rt)
{
    if(l==r)
    {
        scanf("%lld",&sum[rt]);
        return;
    }
    build(l,mid,rt<<1);
    build(mid+1,r,rt<<1|1);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void update(int L,int R,int l,int r,int rt,long long val)
{
    if(l==r)//对区间内的所有点逐个更新
    {
        sum[rt]+=val;
        return;
    }
    if(R<=mid) update(L,R,l,mid,rt<<1,val);
    else if(mid+1<=L) update(L,R,mid+1,r,rt<<1|1,val);
    else
    {
        update(L,mid,l,mid,rt<<1,val);
        update(mid+1,R,mid+1,r,rt<<1|1,val);
    }
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
long long query(int L,int R,int l,int r,int rt)
{
    if(L==l&&R==r) return sum[rt];
    if(R<=mid) return query(L,R,l,mid,rt<<1);
    else if(mid+1<=L) return query(L,R,mid+1,r,rt<<1|1);
    return query(L,mid,l,mid,rt<<1)+query(mid+1,R,mid+1,r,rt<<1|1);
}
int main()
{
    int n,m,L,R;
    long long val;
    char op[5];
    scanf("%d%d",&n,&m);
    build(1,n,1);
    for(int i=1;i<=m;i++)
    {
        scanf("%s",op);
        if(op[0]=='Q')
        {
            scanf("%d%d",&L,&R);
            printf("%lld\n",query(L,R,1,n,1));
        }
        else
        {
            scanf("%d%d%lld",&L,&R,&val);
            update(L,R,1,n,1,val);
        }
    }
    return 0;
}

但是,对每个点逐个进行更新,相当于暴力无疑,这样会很容易超时的,而且也体现不出线段树的优势!!!
所以需要进行延迟更新,延迟更新指等到调用update时或者查询时才更新节点的孩子的值

方法二 :延迟更新法

A Simple Problem with Integers

#include
using namespace std;
typedef long long LL;
const int maxn=100010;
#define lson l,md,(rt<<1)
#define rson md+1,r,(rt<<1|1)
#define ls (rt<<1)
#define rs (rt<<1|1)
#define md ((l+r)>>1)
LL sum[maxn<<2],lazy[maxn<<2];
void up(int rt)
{
    sum[rt]=sum[ls]+sum[rs];
}
void down(int l,int r,int rt)//延迟标记向下(孩子节点)传递
{
    if(lazy[rt])
    {
        sum[ls]+=(md-l+1)*lazy[rt];//更新左孩子节点的val
        lazy[ls]+=lazy[rt];//延迟标记向左孩子传递,以表明我左孩子节点已经更新了,
//但是!!左孩子的子节点还没更新呢!!!

        sum[rs]+=(r-(md+1)+1)*lazy[rt];//更新右孩子
        lazy[rs]+=lazy[rt];//延迟标记向右孩子传递,以表明我右孩子节点已经更新了,
//但是!!右孩子的子节点还没更新呢!!!

        lazy[rt]=0;//当前节点已经更新过了,所以取消标记
    }
}
void build(int l,int r,int rt)
{
    lazy[rt]=0;//初始化为0
    if(l==r)
    {
        scanf("%lld",&sum[rt]);
        return;
    }
    build(lson);
    build(rson);
    up(rt);
}
void update(int L,int R,int l,int r,int rt,LL val)
{
    if(L==l&&r==R)//如果当前要更新的区间和线段树的完美区间一样
    {//那就把当前的区间给它更新,并更新当前节点lazy标记,表明它的两个孩子还没更新
//举个例子,假设总区间为1-12,现在要求更新6-10;假设现在更新到7-9,
//很明显,7-9是线段树的完美区间,所以对该段整段更新:sum[rt]+=(R-L+1)*val;
//但是!!!它的两个孩子节点还没更新呢,它就return了
//所以为这个节点添加延迟标记,以表明它的孩子节点还没更新:lazy[rt]+=val;
        sum[rt]+=(R-L+1)*val;
        lazy[rt]+=val;
        return;
    }
    down(l,r,rt);//如果当前节点有延迟标记,那么更新一下节点的val以及传递延迟标记给孩子节点

    if(md>=R) update(L,R,lson,val);
    else if(md+1<=L) update(L,R,rson,val);
    else{
        update(L,md,lson,val);
        update(md+1,R,rson,val);
    }
    up(rt);
}
LL query(int L,int R,int l,int r,int rt)
{
    if(L==l&&r==R) return sum[rt];
    down(l,r,rt);//如果当前节点有延迟标记,那么更新一下节点的val以及传递延迟标记给孩子节点
    if(md>=R) return query(L,R,lson);
    else if(md+1<=L) return query(L,R,rson);
    return query(L,md,lson)+query(md+1,R,rson);
}
int main() {
    int n,m,L,R;
    LL val;
    char op[5];
    scanf("%d%d",&n,&m);
    build(1,n,1);
    for(int i=1;i<=m;i++)
    {
        scanf("%s",op);
        if(op[0]=='Q')
        {
            scanf("%d%d",&L,&R);
            printf("%lld\n",query(L,R,1,n,1));
        }
        else
        {
            scanf("%d%d%lld",&L,&R,&val);
            update(L,R,1,n,1,val);
        }
    }
    return 0;
}

方法三:
也是延迟更新但是有点不一样,具体请看代码

#include
#include 
#define mid ((l+r)>>1)
using namespace std;
const int MAXN=100010;
long long sum[MAXN*4],mark[MAXN*4];
void build(int l,int r,int rt)
{
    sum[rt]=mark[rt]=0;
    if(l==r)
    {
        scanf("%lld",&sum[rt]);
        return;
    }
    build(l,mid,rt<<1);
    build(mid+1,r,rt<<1|1);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void update(int l,int r,int L,int R,int rt,int val)
{
    sum[rt]=sum[rt]+(R-L+1)*val;
    if(l==L&&R==r)
    {
        mark[rt]+=val;
        return;
    }
    if(R<=mid) update(l,mid,L,R,rt<<1,val);
    else if(L>mid) update(mid+1,r,L,R,rt<<1|1,val);
    else
    {
        update(l,mid,L,mid,rt<<1,val);
        update(mid+1,r,mid+1,R,rt<<1|1,val);
    }
}
long long query(int l,int r,int rt,int L,int R)
{
    if(L==l&&R==r) return sum[rt];
    long long ans=(R-L+1)*mark[rt];
    if(R<=mid) ans+=query(l,mid,rt<<1,L,R);
    else if(L>mid) ans+=query(mid+1,r,rt<<1|1,L,R);
    else
    {
        ans+=query(l,mid,rt<<1,L,mid);
        ans+=query(mid+1,r,rt<<1|1,mid+1,R);
    }
    return ans;
}
int main()
{
    int n,m,L,R;
    long long  val;
    char op[5];
    scanf("%d%d",&n,&m);
    build(1,n,1);
    for(int i=1;i<=m;i++)
    {
        scanf("%s",op);
        if(op[0]=='Q')
        {
            scanf("%d%d",&L,&R);
            printf("%lld\n",query(1,n,1,L,R));
        }
        else
        {
            scanf("%d%d%lld",&L,&R,&val);
            update(1,n,L,R,1,val);
        }
    }
    return 0;
}

( 7 ) 线段树功能： update：区间替换 ，query：区间求和
Just a Hook
题意：
一段线段由n条小线段组成，每次操作把一个区间的小线段变成金银铜之一（金的价值为3，银为2，铜为1），最初可当做全为铜；最后求这条线段的总价值。

#include
using namespace std;
typedef long long LL;
const int maxn=100010;
#define lson l,md,(rt<<1)
#define rson md+1,r,(rt<<1|1)
#define ls (rt<<1)
#define rs (rt<<1|1)
#define md ((l+r)>>1)
LL sum[maxn<<2],lazy[maxn<<2];
void up(int rt)
{
    sum[rt]=sum[ls]+sum[rs];
}
void down(int l,int r,int rt)
{
    if(lazy[rt])
    {
        sum[ls]=(md-l+1)*lazy[rt];
        lazy[ls]=lazy[rt];

        sum[rs]=(r-(md+1)+1)*lazy[rt];
        lazy[rs]=lazy[rt];

        lazy[rt]=0;
    }
}
void build(int l,int r,int rt)
{
    lazy[rt]=0;
    if(l==r)
    {
        sum[rt]=1;
        return;
    }
    build(lson);
    build(rson);
    up(rt);
}
void update(int L,int R,int l,int r,int rt,LL val)
{
    if(L==l&&r==R)
    {
        sum[rt]=(R-L+1)*val;
        lazy[rt]=val;
        return;
    }
    down(l,r,rt);

    if(md>=R) update(L,R,lson,val);
    else if(md+1<=L) update(L,R,rson,val);
    else{
        update(L,md,lson,val);
        update(md+1,R,rson,val);
    }
    up(rt);
}
LL query(int L,int R,int l,int r,int rt)
{
    if(L==l&&r==R) return sum[rt];
    down(l,r,rt);
    if(md>=R) return query(L,R,lson);
    else if(md+1<=L) return query(L,R,rson);
    return query(L,md,lson)+query(md+1,R,rson);
}
int main() {
    int t,n,m,L,R;
    LL val;
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++)
    {
        scanf("%d%d",&n,&m);
        build(1,n,1);
        while(m--)
        {
            scanf("%d%d%lld",&L,&R,&val);
            update(L,R,1,n,1,val);
        }
        printf("Case %d: The total value of the hook is %lld.\n",cas,query(1,1,1,1,1));
    }
    return 0;
}

https://vjudge.net/problem/HDU-1698
( 7 ) 线段树功能： update：区间变为原来的b次方 ，query：区间乘积
题意：操作1： l ,r ,b : 把k∈[l,r] 的妹子, 能力值 a​k变成ak^​b
操作2：l , r : 求累乘 ∏（​l⩽k⩽r）ak
题解：a​^k ≡ a^(​k mod (p−1)) mod p , p是素数.

#include
#include 
using namespace std;
typedef long long LL;
const int maxn=100020;
const LL mod=1000000007;
#define lson l,md,(rt<<1)
#define rson md+1,r,(rt<<1|1)
#define md ((l+r)>>1)
#define ls (rt<<1)
#define rs (rt<<1|1)
LL sum[maxn<<2],lazy[maxn<<2];
LL pow_mod(LL a,int b)
{
    LL res=1;
    while(b)
    {
        if(b&1) res=res*a%mod;
        b>>=1;
        a=a*a%mod;
    }
    return res;
}
void up(int rt)
{
    sum[rt]=sum[ls]*sum[rs]%mod;
}
void down(int l,int r,int rt)
{
     if(lazy[rt]!=1)
    {
        sum[ls]=pow_mod(sum[ls],lazy[rt]);
        lazy[ls]=lazy[ls]*lazy[rt]%(mod-1);

        sum[rs]=pow_mod(sum[rs],lazy[rt]);
        lazy[rs]=lazy[rs]*lazy[rt]%(mod-1);

        lazy[rt]=1;
    }
}
void update(int L,int R,int l,int r,int rt,int b)
{
    if(L==l&&r==R)
    {
        sum[rt]=pow_mod(sum[rt],b);
        lazy[rt]=lazy[rt]*b%(mod-1);
        return;
    }
    down(l,r,rt);
    if(R<=md) update(L,R,lson,b);
    else if(L>md) update(L,R,rson,b);
    else{
        update(L,md,lson,b);
        update(md+1,R,rson,b);
    }
    sum[rt]=sum[ls]*sum[rs]%mod;
}
LL query(int L,int R,int l,int r,int rt)
{
    if(L==l&&r==R) return sum[rt];
    down(l,r,rt);
    if(R<=md) return query(L,R,lson);
    else if(L>md) return query(L,R,rson);
    return query(L,md,lson)*query(md+1,R,rson)%mod;
}
void build(int l,int r,int rt)
{
    lazy[rt]=1;
    if(l==r)
    {
        scanf("%lld",&sum[rt]);
        return ;
    }
    build(lson);
    build(rson);
    sum[rt]=sum[ls]*sum[rs]%mod;
}
int main() {
    int t,n,m;
    scanf("%d", &t);
    while(t--) {
        scanf("%d%d", &n, &m);
        build(1, n, 1);
        while(m--) {
            int op, l, r, b;
            scanf("%d%d%d", &op, &l, &r);
            if(op == 1) {
                scanf("%d", &b);
                update(l,r,1,n,1,b);
            }
            else {
                LL ans = query(l,r,1,n,1);
                printf("%lld\n", ans);
            }
        }
    }
    return 0;
}

你可能感兴趣的:(线段树)

  • BZOJ 五月胡乱补题 nike0good 其他屯题bzoj博客补档
    旧博客搬运部分格式还没来得及改T_T【BZOJ4806:炮】同BZOJ1801【BZOJ3242:[Noi2013]快餐店】树形dp，要么最远点在同一颗树上（dp），要么在不同树上，此时答案=去掉任何一条边后形成的树的答案的最小值，我们枚举去掉的那条边。由于答案=s[i]-s[j]+dis[i]+dis[j]，i，j可以分开考虑，也可以用线段树解决。【BZOJ4878:[Lydsy2017年5月月
  • 线段树（模板） 数学收藏家 线段树
    #includeusingnamespacestd;#defineintlonglong#defineendl'\n'#defineIOSios::sync_with_stdio(false);cin.tie(0);cout.tie(0);#definemaxn100005intn,q;inta[maxn];structnode{intval,lazy;}s[maxn*4];voidpush_up
  • CCF-CSP认证考试（第32次）总结+题解 Romanticroom 算法
    总结：这一次我选了时间较近的一次进行练习，结果有点悲，前两题就一个质因数分解还好，第三题我走了弯路，想通过类似线段树的手段处理，结果还差了系数，最后一个点tle了。。。第四题直接放弃了。。（太菜，没脸见人）第五题还抱有幻想，当然也只有幻想。。后两题只能打暴力了，以我现在水平，希望努力一个月能有所改变吧。题解：（这里只给到三题题解，再往后我也不会了。。）题一：仓库规划西西艾弗岛上共有n个仓库，依次编
  • 数据结构入门（5）——树与二叉树的应用 Dusk Cteator 高级语言程序设计数据结构笔记数据结构算法霍夫曼树二叉树c++
    数据结构入门——树与二叉树的应用文章目录数据结构入门——树与二叉树的应用前言一、压缩与哈夫曼树扩充二叉树哈夫曼算法哈夫曼算法基本思想哈夫曼算法哈夫曼编码二、表达式树如何构造表达式二叉树计算表达式二叉树对应的值三、并查集并查集的实现四、初探线段树与树状数组线段树线段树操作树状数组定义操作树状数组和线段树前言本系列文章将简要介绍数据结构课程入门知识，文章将结合我们学校（吉大）数据结构课程内容进行讲述。
  • 线段树 Cheng Yu 线段树线段树
    基础知识1、线段树是二叉树，且必定是平衡二叉树，但不一定是完全二叉树。2、对于区间[L,R]，令mid=(L+R)/2，则其左子树为[L,mid]，右子树为[mid+1,R]，当L==R时，该区间为线段树的叶子，无需继续往下划分。3、线段树虽然不是完全二叉树，但是可以用完全二叉树的方式去构造并存储它，只是最后一层可能存在某些叶子与叶子之间出现“空叶子”，这个无需理会，同样给空叶子按顺序编号，在遍历
  • 【详解】线段树 CH_Vaniteux 详解数据结构线段树
    线段树详解By岩之痕目录：一：综述二：原理三：递归实现四：非递归原理五：非递归实现六：线段树解题模型七：扫描线八：可持久化(主席树)九：练习题一：综述假设有编号从1到n的n个点，每个点都存了一些信息，用[L,R]表示下标从L到R的这些点。线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是O(log2(n)).线段树的原理，就是，将[1,n]分解成若干特定的子区间(数量
  • CF 967 D. Longest Max Min Subsequence Jiu-yuan 算法数据结构
    原题链接：Problem-D-Codeforces题意：多测，每次给出长度为n的数组，要求找出没有重复元素的，最长的子序列，如果不止一个最长子序列，那么就选择字典序最小的，比较字典序的时候，如果这个元素的下标是奇数，那么就变成负数比较。思路：线段树+贪心，观察题意可知，最终的子序列肯定是正负相间的，那么对于奇数位置，这个数越大越好，对于偶数位置，这个数越小越好。那么就可以贪心的考虑这个问题，设置二
  • E. Linear Kingdom Races Lanthanmum 算法数据结构动态规划
    https://codeforces.com/problemset/problem/115/E线段树优化dpO(n2)->O(nlogn)分析题意发现可以有暴力dpdp(i)是前i条路最大利润dp(i)=dp(i-1)不选第i条路dp(i)=max(dp(j)+val(j)-cost(j))选这i条路dp(i)=max(dp(i-1),max(dp(j)+val(j)-cost(j))显然右边值可
  • c语言专属英语单词,C语言 V 编程英语单词.doc 时间还早 c语言专属英语单词
    编程词汇英汉对照DataStructures基本数据结构Dictionaries字典PriorityQueues堆GraphDataStructures图SetDataStructures集合Kd-Trees线段树NumericalProblems数值问题SolvingLinearEquations线性方程组BandwidthReduction带宽压缩MatrixMultiplication矩阵乘
  • 牛客竞赛数据结构专题班树状数组、线段树练习题 Landing_on_Mars #线段树数据结构算法
    牛客竞赛_ACM/NOI/CSP/CCPC/ICPC算法编程高难度练习赛_牛客竞赛OJG智乃酱的平方数列（线段树，等差数列，多项式）题目描述想必你一定会用线段树维护等差数列吧？让我们来看看它的升级版。请你维护一个长度为5×10^5的数组，一开始数组中每个元素都为0，要求支持以下两个操作：1、区间[l,r]加自然数的平方数组，即al+=1，al+1+=4，al+2+=9，al+3+=16...ar+
  • 主席树求区间第K小模板 Stephen_Curry___ 算法c++数据结构主席树
    主席树（PresidentTree）是一种用于解决区间查询和修改问题的数据结构，通常用于静态区间问题（即查询和修改操作在构建结构之后不再发生变化）。主席树可以高效地处理诸如区间和、区间最值等问题。主席树的实现原理：基本思想：主席树是一种基于分治思想的数据结构，它将原始序列按照每个位置的取值范围进行离散化，然后构建出一棵持久化线段树（PersistentSegmentTree）。持久化线段树：持久化
  • 【算法随笔：HDU 3333 Turing tree】(线段树 | 离线 | 离散化 | 贪心） XNB's Not a Beginner 算法算法哈希算法leetcodec++排序算法
    https://acm.hdu.edu.cn/showproblem.php?pid=3333https://acm.hdu.edu.cn/showproblem.php?pid=3333https://vjudge.net.cn/problem/HDU-3333https://vjudge.net.cn/problem/HDU-3333题目很简单，给出长度为N的数组，Q次询问，每次给出区间[x,
  • 【数据结构题目讲解】BZOJ 3306 - 树 利用DFS序求解 阿史大杯茶 数据结构经典数据结构算法c++
    BZOJ3306-树Description\mathrm{Description}Description给定111棵以111为根节点的nnn个点的树，接下来有mmm次操作：Vxy将xxx点的权值更改为yyyEx将根改为xxx点Qx查询xxx子树的最小值Solution\mathrm{Solution}Solution首先，考虑如果没有换根操作（即E操作），那么直接使用DFS序配合线段树的方式即可解
  • Splay 荼白777 平衡树算法数据结构
    定义Splay是一颗平衡二叉树，但是往往没那么平衡，期望高度是log(n)log(n)log(n)应用不仅支持普通平衡树的操作，包括一些区间问题(一般用线段树解决)的也支持；保证高度的思想对某个结点进行操作的时候，将其旋转到树根；这里的操作指的是像插入，查询等等；也就是说，这跟操作系统的局部性原理类似，某个点既然当前用到了，那么后续肯定还会用到；拉到根结点其实就是进行了一个类似缓存的操作；应用这个
  • 蓝桥杯：C++二叉树 DaveVV 蓝桥杯c++蓝桥杯c++算法数据结构c语言
    二叉树几乎每次蓝桥杯软件类大赛都会考核二叉树，它或者作为数据结构题出现，或者应用在其他算法中。大部分高级数据结构是基于二叉树的，例如常用的高级数据结构线段树就是基于二叉树的。二叉树应用广泛和它的形态有关。二叉树的定义：二叉树的第1层是一个结点，称为根，它最多有两个子结点，分别是左子结点、右子结点，以它们为根的子树称为左子树、右子树。二叉树上的每个结点，都是按照这个规则逐层往下构建出来的。图3.4二
  • 【算法】树状数组和线段树 柳下敲代码 算法算法数据结构c++
    文章目录一、树状数组二、线段树一、树状数组O(logn)O(logn)O(logn)：单点修改、区间查询与前缀和的区别：前缀和是离线的，每次动态修改原数组某个元素，都需要重新求一遍前缀和，因此单点修改是O(n)O(n)O(n)的，区间查询则是O(1)O(1)O(1)树状数组是在线的，单点修改和区间查询都是O(logn)O(logn)O(logn)设下标从111开始//树状数组的定义t[x]=a[x
  • 【图论经典题目讲解】CF786B - Legacy 一道线段树优化建图的经典题目 阿史大杯茶 图论经典图论c++算法
    CF786B−Legacy\mathrm{CF786B-Legacy}CF786B−LegacyDescription\mathrm{Description}Description给定111张nnn个点的有向图，初始没有边，接下来有qqq次操作，形式如下：1uvw表示从uuu向vvv连接111条长度为www的有向边2ulrw表示从uuu向iii（i∈[l,r]i\in[l,r]i∈[l,r]）连接
  • 算法分类合集 weixin_30784945
    算法分类合集ACM所有算法数据结构栈，队列，链表哈希表，哈希数组堆，优先队列双端队列可并堆左偏堆二叉查找树Treap伸展树并查集集合计数问题二分图的识别平衡二叉树二叉排序树线段树一维线段树二维线段树树状数组一维树状数组N维树状数组字典树后缀数组，后缀树块状链表哈夫曼树桶，跳跃表Trie树(静态建树、动态建树)AC自动机LCA和RMQ问题KMP算法图论基本图算法图广度优先遍历深度优先遍历拓扑排序割边
  • ACM算法分类（要学习的东西还很多） 还是太年轻
    ACM所有算法数据结构栈，队列，链表哈希表，哈希数组堆，优先队列双端队列可并堆左偏堆二叉查找树Treap伸展树并查集集合计数问题二分图的识别平衡二叉树二叉排序树线段树一维线段树二维线段树树状数组一维树状数组N维树状数组字典树后缀数组，后缀树块状链表哈夫曼树桶，跳跃表Trie树(静态建树、动态建树)AC自动机LCA和RMQ问题KMP算法图论基本图算法图广度优先遍历深度优先遍历拓扑排序割边割点强连通分
  • ACM算法目录 龍木
    ACM所有算法数据结构栈，队列，链表哈希表，哈希数组堆，优先队列双端队列可并堆左偏堆二叉查找树Treap伸展树并查集集合计数问题二分图的识别平衡二叉树二叉排序树线段树一维线段树二维线段树树状数组一维树状数组N维树状数组字典树后缀数组，后缀树块状链表哈夫曼树桶，跳跃表Trie树(静态建树、动态建树)AC自动机LCA和RMQ问题KMP算法图论基本图算法图广度优先遍历深度优先遍历拓扑排序割边割点强连通分
  • 看歌词猜歌 线段树 myjs999 链表
    voidmodify(node*tempnode,inttempleft,inttempright){if(templeft==tempright){//目标点（叶子结点）tempnode->maxnum=aimnum;return;}intmiddle=(templeft+tempright)/2;if(aimpleftchild,templeft,middle);elsemodify(temp
  • 2021-07-20 RX-0493
    1.MyCowAteMyHomeworkS：坑点：计算小数时，除数一定要强制转化为double型，(ans=sum/(double)(n-i))，ans为double，sum可以为int2.MooFestG：学习了cdq分治，将其中一维从n的枚举，压缩到logn的枚举，枚举区间。[1,1]->[1,2]->[1,4],以此类推3.XOR的艺术：线段树，pushdown还有Add可以实现区间；数组开
  • 基于完全二叉树实现线段树-- [爆竹声中一岁除,线段树下苦踌躇] 摆烂小青菜 图论数据结构算法笔记数据结构深度优先算法
    文章目录一.完全二叉树完全二叉树的父子结点引索关系二.线段树三.基于完全二叉树实现线段树关于线段树的结点数量问题的证明递归建树递归查询区间和递归单点修改线段树模板题一.完全二叉树完全二叉树的物理结构是线性表,逻辑结构是二叉树完全二叉树的父子结点引索关系通过子结点下标引索父结点下标:父结点下标=子节点下标/2;通过父结点下标引索左孩子下标:左孩子下标=父结点下标*2;通过父结点下标引索右孩子下标:右
  • 线段树简单笔记 明月千里赴迢遥 数据结构ACM蓝桥杯
    一经典线段树结构：权值为[L,R]的区间和intL,R,sum;操作1单点修改O（logn）递归找到相应叶子节点，回溯时修改父节点（两个儿子总和）操作2区间查询O(logn)左右两边递归，递归边界为左右两边都被包含，累加其权值最坏耗时4logn区间修改需要懒标记，蓝桥杯一般考不到，即使考到也是特殊区间修改，用不到函数1pushup用子节点信息更新当前节点信息2build在一段区间上初始化线段树3m
  • 数据结构总结 broxin 学习日志
    一、树链刨分按照重儿子分就行了，理论复杂度是log^2的，但事实上常数比较小。我YY了一个优化的方法：如果题目只涉及路径的修改，可以针对每个重链单独建一棵线段树（这样必须用指针表示儿子），然后可以发现除了u,v,lca(u,v)三个点需要深入线段树中，其他的重链在线段树的根节点读了值就直接返回了，这样写复杂度是logn的，操作量特别大的题可以看出明显的差距。但是如果题目同时涉及路径和子树的修改（N
  • 2024.2.6 寒假训练记录（20） Texcavator 2024寒假训练记录算法
    文章目录牛客寒假集训2GTokitsukazeandPowerBattle(easy)牛客寒假集训2HTokitsukazeandPowerBattle(hard)牛客寒假集训2GTokitsukazeandPowerBattle(easy)题目链接好感动，调了好久的一题终于调出来了大体是线段树，pushup的地方稍微修改一下就好了要注意的点是：线段树更新(pushup)的时候，需要用两个子结点重
  • 倍增法+LCA（C/C++） 菜只因C 算法蓝桥杯数据结构C/C++倍增法
    目录1介绍2基本模板1介绍倍增法(binarylifting)，是一种每次将情况翻倍从而将线性处理转化为对数级处理，进而极大优化时间复杂度的方法。2基本模板//预处理复杂度同为O(nlogn),查询时间上，ST表为O(1),线段树为O(logn)#includeusingnamespacestd;constintN=5e4+10;inta[N];//原始输入数组//st表,表示需要查询的数组的从下
  • C++算法之树状数组与线段树 算法下的星辰曲 蓝桥杯c++开发语言
    AcWing1264.动态求连续区间和详细题解AcWing,题解,动态求连续区间和,https://www.acwing.com/solution/content/7526/一、树状数组1.AcWing1264.动态求连续区间和分析思路树状数组c[x]:表示（x-lowbit(x),x]区域的和一个数改变同时也要改变其他位置的数组，下一个父节点是i+lowbit(i)代码实现#include#in
  • 洛谷 P3372 【模板】线段树 1 zzc大魔王 洛谷算法数据结构c++
    题目描述如题，已知一个数列，你需要进行下面两种操作：将某区间每一个数加上k。求出某区间每一个数的和。输入格式第一行包含两个整数n,m，分别表示该数列数字的个数和操作的总个数。第二行包含n个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。接下来m行每行包含3或4个整数，表示一个操作，具体如下：1xyk：将区间[x,y]内每个数加上k。2xy：输出区间[x,y]内每个数的和。输出格式输出包含若
  • P3870 [TJOI2009] 开关 Fool256353 算法
    网址如下：P3870[TJOI2009]开关-洛谷|计算机科学教育新生态(luogu.com.cn)看C艹书看不下去，就到洛谷上随机抽一道题做一道线段树的问题实际上，关于线段树的知识是我现学的（我树的知识都不知道，乐）总结来说，比较重要的就是“懒标记”，加上传值和读取以及构建树的相应操作算法学习网址如下：算法学习笔记(14):线段树-知乎(zhihu.com)第一次用，有点不熟悉，在读取的时候忘记
  • java线程Thread和Runnable区别和联系 zx_code javajvmthread多线程Runnable
    我们都晓得java实现线程2种方式，一个是继承Thread，另一个是实现Runnable。 模拟窗口买票，第一例子继承thread，代码如下 package thread; public class ThreadTest { public static void main(String[] args) { Thread1 t1 = new Thread1(
  • 【转】JSON与XML的区别比较 丁_新 jsonxml
    1.定义介绍 (1).XML定义 扩展标记语言 (Extensible Markup Language, XML) ，用于标记电子文件使其具有结构性的标记语言，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 XML使用DTD(document type definition)文档类型定义来组织数据;格式统一，跨平台和语言，早已成为业界公认的标准。 XML是标
  • c++ 实现五种基础的排序算法 CrazyMizzz C++c算法
    #include<iostream> using namespace std; //辅助函数，交换两数之值 template<class T> void mySwap(T &x, T &y){ T temp = x; x = y; y = temp; } const int size = 10; //一、用直接插入排
  • 我的软件 麦田的设计者 我的软件音乐类娱乐放松
         这是我写的一款app软件，耗时三个月，是一个根据央视节目开门大吉改变的，提供音调，猜歌曲名。1、手机拥有者在android手机市场下载本APP，同意权限，安装到手机上。2、游客初次进入时会有引导页面提醒用户注册。（同时软件自动播放背景音乐）。3、用户登录到主页后，会有五个模块。a、点击不胫而走，用户得到开门大吉首页部分新闻，点击进入有新闻详情。b、
  • linux awk命令详解 被触发 linux awk
    awk是行处理器: 相比较屏幕处理的优点，在处理庞大文件时不会出现内存溢出或是处理缓慢的问题，通常用来格式化文本信息 awk处理过程: 依次对每一行进行处理，然后输出 awk命令形式: awk [-F|-f|-v] ‘BEGIN{} //{command1; command2} END{}’ file [-F|-f|-v]大参数，-F指定分隔符，-f调用脚本，-v定义变量 var=val
  • 各种语言比较 _wy_ 编程语言
                        Java Ruby PHP 擅长领域                  
  • oracle 中数据类型为clob的编辑 知了ing oracle clob
    public void updateKpiStatus(String kpiStatus,String taskId){ Connection dbc=null; Statement stmt=null; PreparedStatement ps=null; try { dbc = new DBConn().getNewConnection(); //stmt = db
  • 分布式服务框架 Zookeeper -- 管理分布式环境中的数据 矮蛋蛋 zookeeper
    原文地址： http://www.ibm.com/developerworks/cn/opensource/os-cn-zookeeper/ 安装和配置详解 本文介绍的 Zookeeper 是以 3.2.2 这个稳定版本为基础，最新的版本可以通过官网 http://hadoop.apache.org/zookeeper/来获取，Zookeeper 的安装非常简单，下面将从单机模式和集群模式两
  • tomcat数据源 alafqq tomcat
    数据库 JNDI(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。 没有使用JNDI时我用要这样连接数据库： 03.  Class.forName("com.mysql.jdbc.Driver");  04.  conn
  • 遍历的方法 百合不是茶 遍历
                                                          遍历 在java的泛
  • linux查看硬件信息的命令 bijian1013 linux
    linux查看硬件信息的命令 一.查看CPU： cat /proc/cpuinfo   二.查看内存： free   三.查看硬盘： df   linux下查看硬件信息 1、lspci 列出所有PCI 设备； lspci - list all PCI devices:列出机器中的PCI设备（声卡、显卡、Modem、网卡、USB、主板集成设备也能
  • java常见的ClassNotFoundException bijian1013 java
    1.java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory   添加包common-logging.jar2.java.lang.ClassNotFoundException: javax.transaction.Synchronization    
  • 【Gson五】日期对象的序列化和反序列化 bit1129 反序列化
    对日期类型的数据进行序列化和反序列化时，需要考虑如下问题：   1. 序列化时，Date对象序列化的字符串日期格式如何 2. 反序列化时，把日期字符串序列化为Date对象，也需要考虑日期格式问题 3. Date A -> str -> Date B,A和B对象是否equals   默认序列化和反序列化     import com
  • 【Spark八十六】Spark Streaming之DStream vs. InputDStream bit1129 Stream
      1. DStream的类说明文档：   /** * A Discretized Stream (DStream), the basic abstraction in Spark Streaming, is a continuous * sequence of RDDs (of the same type) representing a continuous st
  • 通过nginx获取header信息 ronin47 nginx header
    1. 提取整个的Cookies内容到一个变量，然后可以在需要时引用，比如记录到日志里面， if ( $http_cookie ~* "(.*)$") {         set $all_cookie $1; }     变量$all_cookie就获得了cookie的值，可以用于运算了
  • java-65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 bylijinnan java
    参考了网上的http://blog.csdn.net/peasking_dd/article/details/6342984 写了个java版的： public class Print_1_To_NDigit { /** * Q65.输入数字n，按顺序输出从1最大的n位10进制数。比如输入3，则输出1、2、3一直到最大的3位数即999 * 1.使用字符串
  • Netty源码学习-ReplayingDecoder bylijinnan javanetty
    ReplayingDecoder是FrameDecoder的子类，不熟悉FrameDecoder的，可以先看看 http://bylijinnan.iteye.com/blog/1982618 API说，ReplayingDecoder简化了操作，比如： FrameDecoder在decode时，需要判断数据是否接收完全： public class IntegerH
  • js特殊字符过滤 cngolon js特殊字符js特殊字符过滤
    1.js中用正则表达式 过滤特殊字符, 校验所有输入域是否含有特殊符号function stripscript(s) {    var pattern = new RegExp("[`~!@#$^&*()=|{}':;',\\[\\].<>/?~！@#￥……&*（）&mdash;—|{}【】‘；：”“'。，、？]"
  • hibernate使用sql查询 ctrain Hibernate
    import java.util.Iterator; import java.util.List; import java.util.Map; import org.hibernate.Hibernate; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transa
  • linux shell脚本中切换用户执行命令方法 daizj linuxshell命令切换用户
    经常在写shell脚本时，会碰到要以另外一个用户来执行相关命令，其方法简单记下：   1、执行单个命令：su - user -c "command" 如：下面命令是以test用户在/data目录下创建test123目录 [root@slave19 /data]# su - test -c "mkdir /data/test123" 
  • 好的代码里只要一个 return 语句 dcj3sjt126com return
    别再这样写了：public boolean foo() {    if (true) {         return true;     } else {          return false;    
  • Android动画效果学习 dcj3sjt126com android
    1、透明动画效果 方法一：代码实现 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View rootView = inflater.inflate(R.layout.fragment_main, container, fals
  • linux复习笔记之bash shell (4)管道命令 eksliang linux管道命令汇总linux管道命令linux常用管道命令
    转载请出自出处： http://eksliang.iteye.com/blog/2105461     bash命令执行的完毕以后，通常这个命令都会有返回结果，怎么对这个返回的结果做一些操作呢？那就得用管道命令‘|’。     上面那段话，简单说了下管道命令的作用，那什么事管道命令呢？     答：非常的经典的一句话，记住了，何为管
  • Android系统中自定义按键的短按、双击、长按事件 gqdy365 android
    在项目中碰到这样的问题： 由于系统中的按键在底层做了重新定义或者新增了按键，此时需要在APP层对按键事件（keyevent）做分解处理，模拟Android系统做法，把keyevent分解成： 1、单击事件：就是普通key的单击； 2、双击事件：500ms内同一按键单击两次； 3、长按事件：同一按键长按超过1000ms（系统中长按事件为500ms）； 4、组合按键：两个以上按键同时按住；
  • asp.net获取站点根目录下子目录的名称 hvt .netC#asp.nethovertreeWeb Forms
    使用Visual Studio建立一个.aspx文件(Web Forms)，例如hovertree.aspx,在页面上加入一个ListBox代码如下： <asp:ListBox runat="server" ID="lbKeleyiFolder" />   那么在页面上显示根目录子文件夹的代码如下： string[] m_sub
  • Eclipse程序员要掌握的常用快捷键 justjavac javaeclipse快捷键ide
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  写道 程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可
  • c++编程随记 lx.asymmetric C++笔记
     为了字体更好看，改变了格式……   &&运算符：   #include<iostream> using namespace std; int main(){      int a=-1,b=4,k;      k=(++a<0)&&!(b--
  • linux标准IO缓冲机制研究 音频数据 linux
    一、什么是缓存I/O(Buffered I/O)缓存I/O又被称作标准I/O,大多数文件系统默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中，操作系统会将I/O的数据缓存在文件系统的页缓存(page cache)中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。1.缓存I/O有以下优点:A.缓存I/O使用了操作系统内核缓冲区，
  • 随想 生活 暗黑小菠萝 生活
    其实账户之前就申请了，但是决定要自己更新一些东西看也是最近。从毕业到现在已经一年了。没有进步是假的，但是有多大的进步可能只有我自己知道。   毕业的时候班里12个女生，真正最后做到软件开发的只要两个包括我，PS：我不是说测试不好。当时因为考研完全放弃找工作，考研失败，我想这只是我的借口。那个时候才想到为什么大学的时候不能好好的学习技术，增强自己的实战能力，以至于后来找工作比较费劲。我
  • 我认为POJO是一个错误的概念 windshome javaPOJO编程J2EE设计
                  这篇内容其实没有经过太多的深思熟虑，只是个人一时的感觉。从个人风格上来讲，我倾向简单质朴的设计开发理念；从方法论上，我更加倾向自顶向下的设计；从做事情的目标上来看，我追求质量优先，更愿意使用较为保守和稳妥的理念和方法。    &
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他