[kuangbin带你飞]专题七 线段树题解

最新推荐文章于 2020-06-21 18:49:10 发布
最新推荐文章于 2020-06-21 18:49:10 发布
阅读量289 收藏 4
点赞数
分类专栏： [kuangbin带你飞]
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43890047/article/details/90108577
版权

[kuangbin带你飞]专题七 线段树题解

线段树&树状数组

敌兵布阵

HDU-1166
单点修改，区间查询–>最基础的树状数组。直接上代码
代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAX_N = 100000;

int C[MAX_N] = {0};

int N;

int lowbit(int x)
{
    return x&(-x);
}

int getsum(int x)
{
    int sum = 0;
    for(;x;x-=lowbit(x)){
        sum+=C[x];
    }
    return sum;
}

void change(int x,int v)
{
    for(;x<=N;x+=lowbit(x)){
        C[x]+=v;
    }
}

int main()
{
    int T;
    scanf("%d",&T);
    int kase = 0;
    while(T--){
        printf("Case %d:\n",++kase);
        memset(C,0,sizeof(C));
        scanf("%d",&N);
        int n;
        for(int i=1;i<=N;i++){
            scanf("%d",&n);
            change(i,n);
        }
        char que[20] = {0};
        while(scanf("%s",que)&&que[0]!='E'){
            int I,J;
            scanf("%d%d",&I,&J);
            if(que[0]=='A'){
                change(I,J);
            }
            else if(que[0]=='S'){
                change(I,-J);
            }
            else{
                printf("%d\n",getsum(J) - getsum(I-1));
            }
        }
    }
    return 0;
}

I Hate It

HDU-1754
单点更新，区间维护最大值–>用线段树维护最大值。因为用树状数组维护最大值只支持末尾插入元素，不支持线段内更新，所以仅提供线段树维护最值的代码。
代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<iostream>
using namespace std;

const int MAX_N = 200050;
const int inf = 0x3f3f3f3f;

int a[MAX_N] = {0};

int s[MAX_N<<2] = {0};

int N,M;

void up(int p)
{
    s[p] = max(s[2*p],s[2*p+1]);
}

void build(int p,int l,int r)
{
    if(l==r){
        s[p] = a[l];
        return ;///不要漏了
    }
    int mid = (l + r) / 2;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);
    up(p);
}

void modify(int p,int l,int r,int x,int v)
{
    if(l==r){
        s[p] = v;
        return ;
    }
    int mid = (l + r) / 2;

    if(x<=mid){
        modify(2*p,l,mid,x,v);
    }
    else{
        modify(2*p+1,mid+1,r,x,v);
    }
    up(p);
}

int query(int p,int l,int r,int x,int y)
{
    if(x<=l&&r<=y){
        return s[p];
    }
    int mid = (l + r) / 2;
    int res = -inf;
    if(x<=mid){
        res = max(res,query(2*p,l,mid,x,y));
    }
    if(y>mid){
        res = max(res,query(2*p+1,mid+1,r,x,y));
    }
    return res;
}

int main()
{
    while(scanf("%d%d",&N,&M)==2){
        memset(a,0,sizeof(a));
        memset(s,0,sizeof(s));
        for(int i=1;i<=N;i++){
            scanf("%d",a+i);
        }
        build(1,1,N);
        char que[3] = {0};
        int A,B;
        for(int i=1;i<=M;i++){
            scanf("%s%d%d",que,&A,&B);
            if(que[0]=='Q'){
                printf("%d\n",query(1,1,N,A,B));
            }
            else{
                modify(1,1,N,A,B);
            }
        }
    }
    return 0;
}

A Simple Problem with Integers

POJ-3468
区间修改，区间查询和（差）–>有区间修改区间查询功能的树状数组。
直接上代码会好理解。另附上具体指出区间修改区间查询树状数组的原理的博客：差分树状数组
代码：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;

const int MAX_N = 400050;

typedef long long ll;

ll N,Q;

ll c1[MAX_N] = {0},c2[MAX_N] = {0};

ll lowbit(ll x)
{
    return x&(-x);
}

ll getsum(ll x)
{
    ll sum1 = 0;
    ll sum2 = 0;
    for(int i=x;i;i-=lowbit(i)){
        sum1 += (x + 1) * c1[i];
        sum2 += c2[i];
    }
    return sum1 - sum2;
}

void change(int x,ll v)
{
    for(int i=x;i<=N;i+=lowbit(i)){
        c1[i] += v;
        c2[i] += x * v;
    }
}

int main()
{
    scanf("%lld%lld",&N,&Q);
    for(int i=1;i<=N;i++){
        ll v;
        scanf("%lld",&v);
        change(i,v);
        change(i+1,-v);
    }
    char op[3] = {0};
    for(int i=1;i<=Q;i++){
        scanf("%s",op);
        ll a,b,c;
        if(op[0]=='C'){
            scanf("%lld%lld%lld",&a,&b,&c);
            change(a,c);
            change(b+1,-c);
        }
        else{
            scanf("%lld%lld",&a,&b);
            printf("%lld\n",getsum(b) - getsum(a-1));
        }
    }
    return 0;
}

Mayor’s posters

POJ-2528
线段树覆盖可见问题。我们最终通过查询每个叶节点（就是区间上的一个点）来统计数目，所以只需要单点查询。另外涉及区间修改，那么是一颗不需要维护区间信息的线段树。有col[]lazy标记即可，不需要s[]数组。
另外离散化需要注意的点在这个博客里写的比较清楚：离散化+线段树区间覆盖
代码：

#include<math.h>
#include<string.h>
#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=10005;
int n;
int vis[maxn<<3],sum[maxn<<4];
int li[maxn*2],ri[maxn*2],lsh[maxn<<2];
void pushdown(int rt)
{
    sum[rt<<1]=sum[rt];
    sum[rt<<1|1]=sum[rt];
    sum[rt]=-1;
}
void update(int L,int R,int C,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        sum[rt]=C;
        return ;
    }
    if(sum[rt]!=-1)
        pushdown(rt);
    int m=(l+r)>>1;
    if(m>=R) update(L,R,C,l,m,rt<<1);
    else if(L>m) update(L,R,C,m+1,r,rt<<1|1);
    else update(L,m,C,l,m,rt<<1),update(m+1,R,C,m+1,r,rt<<1|1);
}
int ans;
void query(int l,int r,int rt)
{
        if(!vis[sum[rt]]&&sum[rt]!=-1)
        {
            ans++;
            vis[sum[rt]]=1;
        return ;
        }
    if(l==r)
    {
        return ;
    }
    if(sum[rt]!=-1)
        pushdown(rt);
    int m=(l+r)>>1;
    query(l,m,rt<<1);
    query(m+1,r,rt<<1|1);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(sum,-1,sizeof(sum));
        memset(vis,0,sizeof(vis));
        int tot=0;
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&li[i],&ri[i]);
            lsh[tot++]=li[i];
            lsh[tot++]=ri[i];
        }
        sort(lsh,lsh+tot);
        int mm=unique(lsh,lsh+tot)-lsh;
        int tt=mm;
        for(int i=1;i<tt;i++)
        {
            if(lsh[i]-lsh[i-1]>1)
                lsh[mm++]=lsh[i-1]+1;
        }
        sort(lsh,lsh+mm);
        for(int i=0;i<n;i++)
        {
            int x=lower_bound(lsh,lsh+mm,li[i])-lsh;
            int y=lower_bound(lsh,lsh+mm,ri[i])-lsh;
            update(x,y,i,0,mm-1,1);
        }
        ans=0;
        query(0,mm-1,1);
        printf("%d\n",ans);
    }
}

Just a Hook

HDU-1698
线段树区间覆盖值，无查询函数（因为s[1]就是整个区间的和）–>带有区间修改的线段树。
代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define lson l, m, node * 2
#define rson m+1, r, node * 2 + 1
using namespace std;
int sum[500000];
int add[500000];
void pushup(int node)
{
  sum[node] = sum[node * 2] + sum[node * 2 + 1];
}
void pushdown(int node, int m)
{
   if(add[node])
   {
     add[node*2] = add[node*2+1] = add[node];
     sum[node*2] = add[node] * (m - m / 2);
     sum[node*2+1] = add[node] * (m/2);
     add[node] = 0;
   }
}
void Build(int l, int r, int node)
{
   add[node] = 0;
   sum[node] = 1;
   if(l==r)
     return ;
   int m = (l + r) / 2;
   Build(lson);
   Build(rson);
   pushup(node);
}
void updata(int x, int y, int c, int l, int r, int node)
{
    if(x<=l&&r<=y)
    {
       add[node] = c;
       sum[node] = c * (r - l + 1);
       return ;
    }
    pushdown(node, r - l + 1);
    int m = (l + r) / 2;
    if(x<=m)
    updata(x, y, c, lson);
    if(y>m)
    updata(x, y, c, rson);
    pushup(node);//要注意每次都要更新节点
}
int main()
{
  int n, m;
  int T;
  scanf("%d", &T);
  for(int t=1;t<=T;t++)
  {
     scanf("%d %d", &n, &m);
     Build(1, n, 1);
     while(m--)
     {
       int a, b, c;
       scanf("%d %d %d", &a, &b, &c);
       updata(a, b, c, 1, n, 1);
     }
     printf("Case %d: The total value of the hook is %d.\n", t, sum[1]);
  }
  return 0;
}

Count the Colors

ZOJ-1610
跟前面的Mayor’s posters不同的是，同个颜色在非连续区间算是多个色块，都需要统计。而还需考虑连续的一个色块。
下面是WA代码：（有空重新写一次）

#include<cstdio>
#include<cstring>
#include<map>
#include<iostream>
#include <iterator>
using namespace std;
const int MAX_N = 16000;
///这道题要注意所有区间要平移一位

map<int,int> M; ///第一个数字是color，第二个是出现的次数

int col[MAX_N<<2] = {0};

void down(int p)
{
    if(col[p]){
        col[2*p] = col[p];
        col[2*p+1] = col[p];
        col[p] = 0;
    }
}

void modify(int p,int l,int r,int x,int y,int v)
{
    if(x<=l&&r<=y){
        col[p] = v;
        return ;
    }
    down(p);
    int mid = (l + r) / 2;
    if(x<=mid) modify(2*p,l,mid,x,y,v);
    if(y>mid) modify(2*p+1,mid+1,r,x,y,v);
}

int query(int p,int l,int r,int x)
{
    if(l==r){
        return col[p];
    }
    down(p);
    int mid = (l + r) / 2;
    int res = 0;
    if(x<=mid) res = query(2*p,l,mid,x);
    else res = query(2*p+1,mid+1,r,x);
    return res;
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF){
        memset(col,-1,sizeof(col));
        //modify(1,1,MAX_N,1,MAX_N,-1);       ///将区间初始化为-1，因为颜色编号可能为0
        M.clear();
        for(int i=1;i<=n;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            if(a==b) continue;
            modify(1,1,MAX_N,a+1,b,c);
        }
        //cout<<"test:";
        int last_cur = -1;
        for(int i=1;i<=MAX_N;i++){
            int val = query(1,1,MAX_N,i);
            //if(i<=6) cout<<val<<' ';
            if(val!=-1){
                if(!M.count(val)) M[val] = 0;
                if(last_cur!=val) M[val]++;
                last_cur = val;
            }
        }
        //cout<<'\n';
        map<int,int>::iterator it = M.begin();
        while(it!=M.end()){
            printf("%d %d\n",it->first,it->second);
            it++;
        }
        printf("\n");
    }
    return 0;
}

Balanced Lineup

POJ-3264
在一个区间中给出最高和最低的奶牛身高的差值->维护最大值、最小值两颗线段树。
代码：

#include<cstdio>
#include<iostream>
using namespace std;

const int MAX_N = 50005;
const int inf = 0x3f3f3f3f;

//typedef long long ll;

int N,Q;

int s[MAX_N<<2][2] = {0}; //col[MAX_N<<2][2] = {0};

void up(int p,int op)  ///op为1为维护最大值，0是最小值
{
    if(op==1) s[p][op] = max(s[2*p][op],s[2*p+1][op]);
    else s[p][op] = min(s[2*p][op],s[2*p+1][op]);
}

int height[MAX_N] = {0};

void build(int p,int l,int r)
{
    if(l==r){
        s[p][1] = height[l];
        s[p][0] = height[l];
        return ;
    }
    int mid = (l + r) / 2;
    build(2*p,l,mid);
    build(2*p+1,mid+1,r);
    up(p,1);
    up(p,0);
}

int query(int p,int l,int r,int x,int y,int op)
{
    if(x<=l&&r<=y){
        return s[p][op];
    }
    int mid = (l + r) / 2;
    int res1 = 0,res2 = inf;
    if(x<=mid){
        if(op==1) res1 = max(res1,query(2*p,l,mid,x,y,op));
        else res2 = min(res2,query(2*p,l,mid,x,y,op));
    }
    if(y>mid){
        if(op==1) res1 = max(res1,query(2*p+1,mid+1,r,x,y,op));
        else res2 = min(res2,query(2*p+1,mid+1,r,x,y,op));
    }
    if(op==1) return res1;
    else return res2;
}

int main()
{
    scanf("%d%d",&N,&Q);
    for(int i=1;i<=N;i++){
        scanf("%d",&height[i]);
    }
    build(1,1,N);
    for(int i=1;i<=Q;i++){
        int l,r;
        scanf("%d%d",&l,&r);
        printf("%d\n",query(1,1,N,l,r,1) - query(1,1,N,l,r,0));
    }
    return 0;
}

Can you answer these queries?

HDU-4027
好题！这道题告诉我们，在修改区间信息的时候，可以调用query来鉴别一些不需要修改或者非法的区间，然后跳过他们，这个复杂度是仅仅是 O ( l o g n ) 2 O(logn)^2 O(logn)2
第二个，就算是modify区间修改也能实现单点修改 ( n l o g n ) (nlogn) (nlogn)，而这道题因为是单点修改，所以不需要lazy标记。
注意，当一个区间的和等于它的长度的时候，就不需要修改了，因为1开根号后还是1。
上代码：

#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

const int MAX_N = 100050;

typedef long long ll;

int N,M;

ll a[MAX_N];

ll s[MAX_N<<2],col[MAX_N<<2];

/*
#ifdef simple_change
void down(int p,int l,int r)
{
    if(col[p]){
        s[2*p] += col[p] * (r - l + 1);
        s[2*p+1] += col[p] * (r - l + 1);
        col[2*p] += col[p];
        col[2*p+1] += col[p];
        col[p] = 0;
    }
}
#endif // simple_change
*/
void up(int p)
{
    s[p] = s[2*p] + s[2*p+1];
}

void build(int p,int l,int r)
{
    if(l==r){
        s[p] = a[l];
        return ;
    }
    int mid = (l + r) / 2;
    build(2*p,l,mid);
    build(2*p+1,mid+1,r);
    up(p);
}
ll query(int p,int l,int r,int x,int y);

void modify(int p,int l,int r,int x,int y)
{
    if(query(1,1,N,l,r)==(r - l + 1)){	///后面两个参数才是区间的长度
        return ;
    }
    
    ///可以在modify里面使用query来确定哪些区间不需要修改
    ///一般可以可以将复杂度R*n转化为R*logn，十分有效
    ///另外，modify的这种写法可以实现区间x~y的单点修改
    if(l==r){
        s[p] = (int)sqrt((double)s[p]);
        return ;
    }
    int mid = (l + r) / 2;
    if(x<=mid) modify(2*p,l,mid,x,y);
    if(y>mid) modify(2*p+1,mid+1,r,x,y);
    up(p);
}

ll query(int p,int l,int r,int x,int y)
{
    if(x<=l&&r<=y){
        return s[p];
    }
    int mid = (l + r) / 2;
    ll res = 0;
    if(x<=mid) res += query(2*p,l,mid,x,y);
    if(y>mid) res += query(2*p+1,mid+1,r,x,y);
    return res;

}

int main()
{
    int kase = 0;
    while(scanf("%d",&N)==1){
        printf("Case #%d:\n",++kase);
        memset(s,0,sizeof(s));
        memset(col,0,sizeof(col));
        for(int i=1;i<=N;i++){
            scanf("%lld",&a[i]);
        }
        build(1,1,N);
        scanf("%d",&M);
        while(M--){
            int op,x,y;
            scanf("%d%d%d",&op,&x,&y);
            if(y<x) swap(x,y);  ///这个真的有毒，注意xy大小不定
            if(op==1){
                printf("%lld\n",query(1,1,N,x,y));
            }
            else{
                modify(1,1,N,x,y);
            }
        }
        printf("\n");
    }
    return 0;
}

Tunnel Warfare

HDU-1540
这道题其实我是用二分来做的，摧毁一个点，那么将这个点的坐标存入vector中，满足排序的条件后排一次序。但是不知道为什么tle了。
上个TLE代码：（下面还有AC代码）

#include<vector>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<cstring>
using namespace std;

const int MAX_N = 50050;
const int inf = 0x3f3f3f3f;

vector<int> vec_0;    ///0的下标，用于二分查找

/*
struct node
{
    int ind;
    bool needed_add;
    node(int ind=0,int needed_add=0):ind(ind),needed_add(needed_add){}
};
*/
stack<int> S;    ///0的键入



int vis_0[MAX_N] = {0};

int N,M;

int main()
{
    while(scanf("%d%d",&N,&M)==2){
        vec_0.clear();
        memset(vis_0,0,sizeof(vis_0));
        while(!S.empty()) S.pop();
        int cnt_D=2,cnt_R=0;
        vec_0.push_back(0);
        vec_0.push_back(N+1);   //用于限定1~N的边界

        int flag = 0;   ///用于确定是否需要排序
        for(int i=1;i<=M;i++){
            //printf("kase %d:",i);
            //for(int i=0;i<vec_0.size();i++) printf("%d ",vec_0[i]);
            //printf("\n");
            char op[3] = {0};
            int ind;
            scanf("%s",op);
            if(op[0]=='D'){
                scanf("%d",&ind);
                if(!vis_0[ind]){    ///就说明vec_0里面没有ind
                    vec_0.push_back(ind);
                    //cnt_D++;///数组长度增加。不能用size，因为有其他无关值
                    flag = 1;   ///查询的时候要排一次序
                    vis_0[ind] = 1;
                }
                S.push(ind);    ///考虑到恢复是上一个的取值，S还是要push
            }
            else if(op[0]=='Q'){
                scanf("%d",&ind);
                if(flag){
                    sort(vec_0.begin(),vec_0.end(),less<int>());
                    //cnt_D -=cnt_R;
                    //cnt_R = 0;
                    flag = 0;
                }
                auto px1 = lower_bound(vec_0.begin(),vec_0.end(),ind);
                auto px2 = px1-1;
                if(*px1==ind){
                    printf("0\n");
                    continue;
                }
                printf("%d\n",*px1 - *px2 - 1);
            }
            else{
                if(!S.empty()){
                    //printf("t1:\n");
                    int indp = S.top();
                    S.pop();
                    sort(vec_0.begin(),vec_0.end(),less<int>());
                    auto px = lower_bound(vec_0.begin(),vec_0.end(),indp);
                    ///px的内容就代表vec_0的值
                    //printf("t1,*px:%d ind:%d\n",*px,indp);
                    if(*px==indp){
                        *px = inf;
                        //cnt_R++;
                        flag = 1;
                    }
                    vis_0[indp] = 0;
                }
            }
        }

    }
    return 0;
}

其实这个跟博主之前写过的黑白棋子有异曲同工之处，都是维护最长连续区间的题目，现在也贴出那篇博客：黑白石头
我们需要做的是维护左右两个连续最大子区间，加上中间连续区间构成最大连续区间，向上传递的时候就负责维护好这三个区间段。
代码：（记得自己也敲多几次，加上黑白棋子。这道题比黑白棋子容易，可作为最大连续区间的入门题目）

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <stdlib.h>
using namespace std;
 
const int maxn = 50000+10;
 
int n,m;
int s[maxn],top;//s为模拟栈
 
struct node
{
    int l,r;
    int ls,rs,ms;//ls,左端最大连续区间，rs右端最大连续区间，ms区间内最大连续区间
} a[maxn<<2];
 
void init(int l,int r,int i)
{
    a[i].l = l;
    a[i].r = r;
    a[i].ls = a[i].rs = a[i].ms = r-l+1;
    if(l!=r)
    {
        int mid = (l+r)>>1;
        init(l,mid,i*2);
        init(mid+1,r,2*i+1);
    }
}
 
void insert(int i,int t,int x)
{
    if(a[i].l == a[i].r)
    {
        if(x==1)
            a[i].ls = a[i].rs = a[i].ms = 1;//修复
        else
            a[i].ls = a[i].rs = a[i].ms = 0;//破坏
        return ;
    }
    int mid = (a[i].l+a[i].r)>>1;
    if(t<=mid)
        insert(2*i,t,x);
    else
        insert(2*i+1,t,x);
    a[i].ls = a[2*i].ls;//左区间
    a[i].rs = a[2*i+1].rs;//右区间
    a[i].ms = max(max(a[2*i].ms,a[2*i+1].ms),a[2*i].rs+a[2*i+1].ls);//父亲区间内的最大区间必定是，左子树最大区间，右子树最大区间，左右子树合并的中间区间，三者中最大的区间值
    if(a[2*i].ls == a[2*i].r-a[2*i].l+1)//左子树区间满了的话，父亲左区间要加上右孩子的左区间
        a[i].ls += a[2*i+1].ls;
    if(a[2*i+1].rs == a[2*i+1].r-a[2*i+1].l+1)//同理
        a[i].rs += a[2*i].rs;
}
 
int query(int i,int t)
{
    if(a[i].l == a[i].r || a[i].ms == 0 || a[i].ms == a[i].r-a[i].l+1)//到了叶子节点或者该访问区间为空或者已满都不必要往下走了
        return a[i].ms;
    int mid = (a[i].l+a[i].r)>>1;
    if(t<=mid)
    {
        if(t>=a[2*i].r-a[2*i].rs+1)//因为t<=mid，看左子树，a[2*i].r-a[2*i].rs+1代表左子树右边连续区间的左边界值，如果t在左子树的右区间内，则要看右子树的左区间有多长并返回
            return query(2*i,t)+query(2*i+1,mid+1);
        else
            return query(2*i,t);//如果不在左子树的右边界区间内，则只需要看左子树
    }
    else
    {
        if(t<=a[2*i+1].l+a[2*i+1].ls-1)//同理
            return query(2*i+1,t)+query(2*i,mid);
        else
            return query(2*i+1,t);
    }
}
 
int main()
{
    int i,j,x;
    char ch[2];
    while(~scanf("%d%d",&n,&m))
    {
        top = 0;
        init(1,n,1);
        while(m--)
        {
            scanf("%s",ch);
            if(ch[0] == 'D')
            {
                scanf("%d",&x);
                s[top++] = x;
                insert(1,x,0);
            }
            else if(ch[0] == 'Q')
            {
                scanf("%d",&x);
                printf("%d\n",query(1,x));
            }
            else
            {
                if(x>0)
                {
                    x = s[--top];
                    insert(1,x,1);
                }
            }
        }
    }
 
    return 0;
}

Assign the task

HDU-3974
本来好好介绍了dfs序，但电脑蓝屏没保存上，真的伤。
这道题适合已经学过图论的同学做的。本文贴的代码用的是链式前向星+dfs，用dfs的方式，将入栈u的左侧记为left[u]，出栈的右侧记为right[u]，那么(left[u],right[u])的线段就是u的子节点（下属）所属区间。根据left和right数组来维护线段树。查询就按left[v]来查。
关于dfs序，这篇博客写的很好：树 DFS序 详解[完全版]

#include<cstdio>
#include<cstring>
using namespace std;

const int MAX_N = 50050,MAX_M = 50049;

void init();

int p[MAX_N] = {0},eid;

int N,M;



struct E
{
    int v,next;
}edge[MAX_M];

void insert1(int u,int v)
{
    edge[eid].v = v;
    edge[eid].next = p[u];
    p[u] = eid++;
}

int left[MAX_N],right[MAX_N];

int vis[MAX_N];

int cnt = 1;

void dfs(int u)
{
    left[u] = cnt++;
    vis[u] = 1;
    for(int i=p[u];i!=-1;i=edge[i].next){
        dfs(edge[i].v);
    }
    right[u] = cnt++;
}

int col[MAX_N<<3];

void init()
{
    memset(p,-1,sizeof(p));
    memset(edge,0,sizeof(edge));
    memset(left,0,sizeof(left));
    memset(right,0,sizeof(right));
    memset(vis,0,sizeof(vis));
    memset(col,-1,sizeof(col));//初始为-1
    cnt = 1;
    eid = 0;
}

void down(int p)
{
    if(col[p]){
        col[2*p] = col[p];
        col[2*p+1] = col[p];
        col[p] = 0; ///不管什么情况都是写成0，不然都要向下传递了
    }
}

void modify(int p,int l,int r,int x,int y,int v)
{
    if(x<=l&&r<=y){
        col[p] = v;
        return ;
    }
    down(p);
    int mid = (l + r) / 2;
    if(x<=mid) modify(2*p,l,mid,x,y,v);
    if(y>mid) modify(2*p+1,mid+1,r,x,y,v);
    //up(p);
}

int query(int p,int l,int r,int x)
{
    if(l==r){
        return col[p];
    }
    down(p);
    int mid = (l + r) / 2;
    int res = 0;
    if(x<=mid) res = query(2*p,l,mid,x);
    else res = query(2*p+1,mid+1,r,x);
    return res;
}

int main()
{
    int T;
    scanf("%d",&T);
    int kase = 0;
    while(T--){
        printf("Case #%d:\n",++kase);
        init();
        scanf("%d",&N);
        int u,v;
        for(int i=1;i<N;i++){
            scanf("%d%d",&u,&v);
            insert1(v,u);
            vis[u] = 1;
        }
        for(int i=1;i<=N;i++){
            if(!vis[i]){
                //printf("test2:u:%d\n",i);
                dfs(i);
                break;
            }
        }
        /*
        printf("begin\n");
        for(int i=1;i<=N;i++){
            printf("%d %d\n",left[i],right[i]);
        }
        printf("end\n");
        */
        scanf("%d",&M);
        char op[3] = {0};
        while(M--){
            scanf("%s",op);
            if(op[0]=='C'){
                int ind;
                scanf("%d",&ind);
                printf("%d\n",query(1,1,2*N,left[ind]));
            }
            else{
                int ind,test;
                scanf("%d%d",&ind,&test);
                //printf("test1:%d %d\n",left[ind],right[ind]);
                modify(1,1,2*N,left[ind],right[ind],test);
            }
        }
    }

    return 0;
}

Transformation

HDU-4578

AC题解
贴一个WA的题解。有时间再做多一次

#include<cstdio>
using namespace std;

typedef long long ll;

const int MOD = 10007;
const int MAX_N = 1e5+5;

int N,M;

ll qp(ll base,ll n)
{
    ll res = 1;
    while(n){
        if(n&1){
            res = res * base;
            res %= MOD;
        }
        base = base * base;
        base %= MOD;
        n>>=1;
    }
    return res;
}

ll col[MAX_N<<2];
ll s[MAX_N<<2];    ///维护pow==1的求和数组，用于减少被乘运算

void down(int p,int l,int r,int op)
{
    if(col[p]){
        int mid = (l + r) / 2;
        if(op==1){
            col[2*p] = (col[2*p] + col[p])%MOD;
            col[2*p+1] = (col[2*p+1] + col[p])%MOD;
            s[2*p] = (s[2*p] + col[p] * (mid - l + 1))%MOD;
            s[2*p+1] = (s[2*p+1] + col[p] * (r - mid))%MOD;
            col[p] = 0;
        }
        else if(op==2){
            col[2*p] = (col[2*p] * col[p])%MOD;
            col[2*p+1] = (col[2*p+1] * col[p])%MOD;
            s[2*p] = (s[2*p] * col[p])%MOD;
            s[2*p+1] = (s[2*p+1] * col[p])%MOD;
            col[p] = 0;
        }
        else{   ///op==3
            col[2*p] = col[p]%MOD;
            col[2*p+1] = col[p]%MOD;
            s[2*p] = (col[p] * (mid - l + 1))%MOD;
            s[2*p+1] = (col[p] * (r - mid))%MOD;
            col[p] = 0;
        }
    }
}

void up(int p)
{
    s[p] = (s[2*p] + s[2*p+1])%MOD;
}

void modify(int p,int l,int r,int x,int y,ll v,int op)
{
    if(x<=l&&r<=y){
        if(op==1){
            col[p] += v;
            s[p] += v * (r - l + 1);
        }
        else if(op==2){
            col[p] *= v;
            s[p] *= v;
        }
        else{   ///op==3
            col[p] = v;
            s[p] = v * (r - l + 1);
        }
        return ;
    }
    down(p,l,r,op);
    int mid = (l + r) / 2;
    if(x<=mid){
        modify(2*p,l,mid,x,y,v,op);
    }
    if(y>mid){
        modify(2*p+1,mid+1,r,x,y,v,op);
    }
    up(p);
}

int query1(int p,int l,int r,int x,int y)       ///用于求pow==1的s的区间和，用于下面query2的查询优化
{
    if(x<=l&&r<=y){
        return s[p];
    }
    down(p,l,r,1);
    int mid = (l + r) / 2;
    int res = 0;
    if(x<=mid){
        res += query1(2*p,l,mid,x,y);
    }
    if(y>mid){
        res += query1(2*p+1,mid+1,r,x,y);
    }
    return res;
}
//ll ans = 0; ///记得每次查询都要初始化为0不用，用不上ans
int query2(int p,int l,int r,int x,int y,int powx)
{
    if(query1(1,1,N,l,r)==0){
        return 0;   ///当这个区的数全为0，那么就不用pow了，和就为0
    }
    ///这道题全部是1的不能维护，因为有可能1,1,1,1,0,2,也能满足(r-l+1)的条件
    if(l==r){
        return qp(s[p],powx);         ///这里写col[p]或者是s[p]都可以
    }
    //down(p);
    int mid = (l + r) / 2;
    ll res = 0;
    if(x<=mid){
        res += query2(2*p,l,mid,x,y,powx);
    }
    if(y>mid){
        res += query2(2*p+1,mid+1,r,x,y,powx);
    }
    return res%MOD;
}


int main()
{
    while(scanf("%d%d",&N,&M)==2&&N){
        for(int i=0;i<(N<<2);i++){
            col[i] = s[i] = 0;
        }   ///初始化
        int op,x,y,c;
        for(int i=1;i<=M;i++){
            scanf("%d%d%d%d",&op,&x,&y,&c);
            if(op==4){
                printf("%d\n",query2(1,1,N,x,y,c));
            }
            else{
                modify(1,1,N,x,y,c,op);
            }
        }
    }
    return 0;
}
///wa了，不过我觉得思路没有错。也可以把立方和拆开，研究规律即可
///应该是加乘的col不能放一起。分开就行


							这里是分割线

题目尚且没有补完，仅先开此博客。

KineXense
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin 模板
09-08
kuangbin 模板
[kuangbin带你飞]专题七 线段树
Kiwi21
10-01 865
点击打开链接 A（hdu 1166 敌兵布阵 ）中文体面，线段树单点更新,求一段区间和 #include #include #include #include #include #include #include #include #include #include #include using namespace std; #define LL long long #define inf
[kuangbin带你飞]专题七 线段树 H HDU-4027
寻梦道理的专栏
10-01 271
题意 2种操作，1：区间里所有数开平方，0:区间和 不能像平时那样用lazy成段更新，因为每个数的更新不是统一的，不是一起增加k，或是变成k，所以成段更新是比较困难的。。 但考虑到数的大小是k #include #include #include #include #define lid (id<<1) #define rid (id<<1|1) using namespace s
Kuangbin 带你飞-线段树专题 题解
deko2014的博客
10-14 157
HDU 1166敌兵布阵 单调更新区间查询和 #include <map> #include <set> #include <list> #include <cmath> #include <ctime> #include <deque> #include <stack> #i...
[kuangbin带你飞]专题七 线段树 题解（未完）
笔记
04-05 564
[kuangbin带你飞]专题七 线段树题解： A 经典的单点更新，区间求和：#include<bits/stdc++.h> using namespace std; #define root 1,n,1 #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 const int N=5e4+10; int n,sum[N<<2]; void push_
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
《kuangbin的ACM模板（新）》是一个专门针对ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）比赛设计的算法模板，由知名程序员kuangbin提供。这个压缩包包含了一份kuangbin的ACM算法...
kuangbin的ACM模板（新） .zip_kuangbin的ACM模板（新）
09-23
"kuangbin的ACM模板（新） .zip_kuangbin的ACM模板（新）" 这个标题表明这是一个压缩文件，其中包含kuangbin开发或整理的新的ACM（国际大学生程序设计竞赛）比赛模板。ACM竞赛是全球性的编程竞赛，参赛者需要在限定...
[kuangbin带你飞]专题七 线段树 hdu1542 扫描线
bjfu170203101的博客
05-29 151
cov存的是树上每个节点代表的区间的覆盖次数， 不用延迟标记下传的原因：因为每次我们只需要len【1】，即整个区间的信息。 每次更新的时候会自下向上更新到len【1】，所以不需要下传。 这个扫描线是覆盖2次以上才计算 我们维护线段树的时候，更新的时候比起板子有些变化、 //我们每次更新的时候只更新一个节点，不会把cov标记进行下传[即延迟标记不会下传，可以下传，但...
[kuangbin带你飞]专题七 线段树--HDU1698 （线段树基本区间操作，这里用区间染色的方法去做）
qq_45377553的博客
05-14 134
E - Just a Hook HDU - 1698 题意： 有一条钩子，初始时颜色为铜（value为1），长度为n。 问你进行m次区间颜色的改变后，总价值。 思路：（染色） AC #include <iostream> #include <cstdio> #include <cstring> #include <algorithm> #define mst(x,a) memset(x,a,sizeof(x)) #define For(i,x,y) for(r
kuangbin线段树专题解析
Originum的博客
10-07 1087
赛前再巩固一下线段树，又做了一遍kuangbin线段树专题 专题链接：kuangbin专题题目一览 1. HDU 1166 敌兵布阵 区间维护和，单点修改 #include &lt;stdio.h&gt; using namespace std; const int MAXN=1e5 + 10; int origin[MAXN], tree[MAXN&lt;&lt;2]; void p...
[kuangbin带你飞]专题七线段树 更新ing
xxxxxiao123的博客
06-21 252
你可能会以为自己再按着专题的顺序来进行刷题，但是实则不然，其实我本来想去做做搜索进阶这个专题，结果第一个提的难度就比较坑爹，想了想算了，先写一下线段树吧。其实每个专题都觉得恶心 淦 之前写的一个无任何添加剂的模板（甚至连注释都没有） 线段树 文章目录HDU 1166 敌兵布阵（线段树单点修改） HDU 1166 敌兵布阵（线段树单点修改） #pragma GCC optimize(3,"O...
NC57供应商管理.pdf
最新发布
07-11
NC57供应商管理
古典花纹毕业答辩PPT模板
07-11
【作品名称】：古典花纹毕业答辩PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
高性能电动摩托车全球前10强生产商排名及市场份额（by QYResearch）.docx
07-11
高性能电动摩托车全球前10强生产商排名及市场份额（by QYResearch）.docx
毕业答辩计划总结工作汇报PPT模板
07-11
【作品名称】：毕业答辩计划总结工作汇报PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：毕业答辩计划总结工作汇报PPT模板
并查集板子llkkyyy
08-19
- *1* *2* [「kuangbin带你飞」专题五并查集专题题解](https://blog.csdn.net/weixin_51216553/article/details/121643742)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值