線段樹學習筆記及模板

原創 brainache 2020-02-24 14:07

概括：線段樹是一種數據結構，針對需要動態 修改並且獲取數據中一段信息（子段和，子段最小值等）的數據來使用

大體思路：使用一顆完全二叉樹（數組實現）記錄數據。樹的葉子節點記錄每一個數據元素，非葉子節點記錄段信息。

建樹，查詢，修改都由二叉樹的性質：第i個節點的左右孩子爲2*i+1,2*i+2   遞歸的執行



建樹思路：從根向下遞歸找葉子->找到葉子後對葉子賦值->賦值完葉子後回溯賦段信息

查找（查詢某一段的信息）思路：從根向下遞歸點的段信息：

                     對於和查找的段沒有交集的段，剪枝掉

                     對於被要查找的段包住的段，符合要求，回溯

                     其他的段向下遞歸，回溯合併的段信息

點修改思路：從根向下遞歸找葉子，找到需要的點就修改，在回溯中更新段信息    

特別的操作1：段修改 

                       對一段元素做同一操作，勢必會影響到非葉子節點。

                       對於像給一段元素加上同一值這樣的操作，可以直接給代表這段的節點操作：記錄到延時標誌上面，並不更新其他的值，把更新操作留到查詢操作中解決。

                      對於段賦值，就需要在對這一段修改前確保這一段處於改了也沒問題的狀態，即延時標記爲0

                       由於下推操作只有O(1)的複雜度所以可以到處用

                      所以在進行修改前下推一下就行了

    #include <bits/stdc++.h>

    using namespace std;
    const int maxn=1000;

    //用於存放線段樹的結構 l,r表示此區間的左右端點
    struct segn
    {
        int data,l,r,mi,su,mark_add;
    }segt[maxn];
    //建樹:葉節點終止條件->遞歸建左右子樹->由左右孩子信息得到此節點信息
    void push_dowm(int root)
    {
        if(segt[root].mark_add!=0)
        {
            int st=segt[root].l;
            int en=segt[root].r;
            segt[root].su+=segt[root].mark_add*(en-st+1);
            segt[root].mi+=segt[root].mark_add;
            segt[root*2+1].mark_add+=segt[root].mark_add;
            segt[root*2+2].mark_add+=segt[root].mark_add;
            segt[root].mark_add=0;
        }
    }
    void build(int *dat,int root,int st,int en)
    {
        //st,en表示目前區間的首尾端點序號,dat[]表示用於初始化的數據
        //記錄左右端點
        segt[root].l=st;
        segt[root].r=en;
        if(st==en)//在葉子節點上加入元素數據
        {
            segt[root].data=dat[st];
            segt[root].mark_add=0;
            segt[root].mi=segt[root].data;//求區間最小值的操作
            segt[root].su=segt[root].data;//求區間和的操作
            return;
        }
        //對於非葉子節點
        int mid=(st+en)/2;//分割點
        //由二叉性，數組存樹的左右節點編號分別爲此節點的*2+1和*2+2
        build(dat,root*2+1,st,mid);//遞歸建左子樹
        build(dat,root*2+2,mid+1,en);//右子樹
        //由左右子樹得到此節點的數據
        //求區間最小值
        segt[root].mi=min(segt[root*2+1].mi,segt[root*2+2].mi);
        //求區間和
        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;
    }

    /*
    //查詢的模板
    int query_(int qst,int qen,int tst,int ten,int root)
    {//查詢子段和
        push_dowm(root);
        if(qst>ten||qen<tst)//想查的區間和正在查區間的沒有重疊，剪枝
            return 一個對合並值沒有效果的值;
        if(tst>=qst&&ten<=qen)//正在查的區間比想查的小或者相等，符合
            return segt[root].數據;
        int mid =(tst+ten)/2;
        return 子段合併操作//搜索左右子樹
    }
   */
    const int bigmun=1e7;
    //下推操作在查詢中完成
    int query_mi(int qst,int qen,int tst,int ten,int root)//查詢操作：向下遞歸的找區間，只要找到被要找的區間包括的區間，就可以肯定這個區間是需要的（因爲向下遞歸的順序和不交叉的順序）
    {//查詢最小值
        //qst,qen:想查詢的區間  tst,ten:正在查的區間
        push_dowm(root);
        if(qst>ten||qen<tst)//想查的區間和正在查區間的沒有重疊，剪枝
            return bigmun;
        if(tst>=qst&&ten<=qen)//正在查的區間比想查的小或者相等，符合
            return segt[root].mi;
        int mid =(tst+ten)/2;

        return min(query_mi(qst,qen,tst,mid,root*2+1),query_mi(qst,qen,mid+1,ten,root*2+2));//搜索左右子樹
    }
    int query_sum(int qst,int qen,int tst,int ten,int root)
    {//查詢子段和
         push_dowm(root);
        if(qst>ten||qen<tst)//想查的區間和正在查區間的沒有重疊，剪枝
            return 0;
        if(tst>=qst&&ten<=qen)//正在查的區間比想查的小或者相等，符合
            return segt[root].su;
        int mid =(tst+ten)/2;

        return query_sum(qst,qen,tst,mid,root*2+1)+query_sum(qst,qen,mid+1,ten,root*2+2);//搜索左右子樹
    }

    void adjust_elemt(const int addval,const int pos,int st,int en,int root)//點修改，給pos位置的元素加上addval
    {//思路：遞歸一遍，查找並修改需要修改的元素，然後把路徑更新一遍
        if(st==en)
        {
            if(st==pos)
            {//在這裏進行元素修改
                segt[root].data+=addval;
                segt[root].mi+=addval;//最小值
                segt[root].su+=addval;//子段和
            }
            return;
        }
        int mid=(st+en)/2;
        if(pos<=mid)
        adjust_elemt(addval,pos,st,mid,root*2+1);
        else
        adjust_elemt(addval,pos,mid+1,en,root*2+2);
        //在這裏進行段修改
        segt[root].mi=min(segt[root*2+1].mi,segt[root*2+2].mi);//最小值段修改
        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;//子段和段修改
    }
    void segadd(int qst,int qen,int tst,int ten,int root,int addnum)
    {//全段加
        if(qst>ten||qen<tst)//不符合的區間
            {
                return ;
            }
        if(tst>=qst&&ten<=qen)//找到要加的區間
            {
                segt[root].mark_add+=addnum;
                return ;
            }
        int mid =(tst+ten)/2;
        if(tst>qst&&ten>qen)segt[root].su+=addnum*(qen-tst+1)*addnum;
        else if(tst<qst&&ten<qen)segt[root].su+=addnum*(ten-qst+1)*addnum;
        else segt[root].su+=addnum*(qen-qst+1);
        segadd(qst,qen,tst,mid,root*2+1,addnum);
        segadd(qst,qen,mid+1,ten,root*2+2,addnum);//搜索左右子樹
       // segt[root].mark_add+=addthis;
       // return addthis;
    }
    int main()
    {
        const int sz=17;
        int arr[sz+1];
        for(int i=0;i<sz+1;i++)arr[i]=1;
        build(arr,0,0,sz);
        int j=2,cur;
        // adjust_elemt(-1000,4,0,50,0);
        segadd(0,3,0,sz,0,-1);

        for(int i=0;i<=sz;i++)query_mi(i,i,0,sz,0);

        for(int i=0;i<sz*2+1;i++)
        {
            cout<<segt[i].l<<"~"<<segt[i].r<</*":segmin:"<<segt[i].mi<<*/" segsum:"<<segt[i].su<</*" segmark:"<<segt[i].mark_add<<*/" ";
            if(i+2==j)
            {
                cout<<endl;
                j*=2;
            }
        }


        //測試build
        //cout<<query_mi(5,10,0,50,0);
        //cout<<query_sum(0,2,0,50,0);
        return 0;
    }



hdu 1166  敵兵佈陣

直接套模板的題，然而神志不清的手滑了半天


#include<cstdio>
#include<iostream>

    using namespace std;
    const int maxn=200000;
    int sz=1;
    //用於存放線段樹的結構 l,r表示此區間的左右端點
    struct segn
    {
        int data,l,r,mi,su,mark_add;
    }segt[maxn];
    //建樹:葉節點終止條件->遞歸建左右子樹->由左右孩子信息得到此節點信息

    void build(int *dat,int root,int st,int en)
    {

        //st,en表示目前區間的首尾端點序號,dat[]表示用於初始化的數據
        //記錄左右端點

        if(st==en)//在葉子節點上加入元素數據
        {

            segt[root].su=dat[st];//求區間和的操作
            return;
        }
        //對於非葉子節點
        int mid=(st+en)/2;//分割點
        //由二叉性，數組存樹的左右節點編號分別爲此節點的*2+1和*2+2
        build(dat,root*2+1,st,mid);//遞歸建左子樹
        build(dat,root*2+2,mid+1,en);//右子樹
        //由左右子樹得到此節點的數據
        //求區間最小值

        //求區間和
        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;
    }


    int query_sum(int qst,int qen,int tst,int ten,int root)
    {//查詢子段和


        if(qst>ten||qen<tst)//想查的區間和正在查區間的沒有重疊，剪枝
            return 0;
        if(tst>=qst&&ten<=qen)//正在查的區間比想查的小或者相等，符合
            return segt[root].su;
        int mid =(tst+ten)/2;

        return query_sum(qst,qen,tst,mid,root*2+1)+query_sum(qst,qen,mid+1,ten,root*2+2);//搜索左右子樹
    }

    void adjust_elemt(const int addval,const int pos,int st,int en,int root)//點修改，給pos位置的元素加上addval
    {//思路：遞歸一遍，查找並修改需要修改的元素，然後把路徑更新一遍
      /*  if(en>sz)
        {
            int k=0;
            while(++k){k=1;}
        }*/
        if(st==en)
        {
            if(st==pos)
            {//在這裏進行元素修改


                segt[root].su+=addval;//子段和
            }
            return;
        }
        int mid=(st+en)/2;
        if(pos<=mid)
        adjust_elemt(addval,pos,st,mid,root*2+1);
        else
        adjust_elemt(addval,pos,mid+1,en,root*2+2);
        //在這裏進行段修改

        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;//子段和段修改
    }
    int main()
    {
        int t,n,arr[65536],counn=0;
        string comm;
        scanf("%d",&t);
        while(t--)
        {
            bool flag=true;

            scanf("%d",&n);
            for(int i=0;i<n;i++)
            {
                scanf("%d",&arr[i]);
            }

            sz=n;
            build(arr,0,0,sz-1);
            //for(int i=0;i<2*sz;i++)cout<<segt[i].su<<" ";
            int st,en,ad;
            cout<<"Case "<<++counn<<":"<<endl;
            while(cin>>comm)
            {
                if(comm=="End")break;
                if(comm=="Query")
                {

                     scanf("%d%d",&st,&en);
                    cout<<query_sum(st-1,en-1,0,sz-1,0)<<endl;
                    continue;
                }
                if(comm=="Add"){scanf("%d%d",&st,&ad);}
                if(comm=="Sub"){scanf("%d%d",&st,&ad);ad=-ad;}
                adjust_elemt(ad,st-1,0,sz-1,0);
            }
        }
        return 0;
    }

hdu 1754

I Hate It

同樣是模板題

 #include <cstdio>
 #include<iostream>

    using namespace std;
    const int maxn=200000*4;
    int Max(int x,int y){return x>=y ? x:y;}
    //用於存放線段樹的結構 l,r表示此區間的左右端點
    struct segn
    {
        int data,l,r,mi,su,mark_add;
    }segt[maxn];
    //建樹:葉節點終止條件->遞歸建左右子樹->由左右孩子信息得到此節點信息

    void build(int *dat,int root,int st,int en)
    {
        //st,en表示目前區間的首尾端點序號,dat[]表示用於初始化的數據
        //記錄左右端點

        if(st==en)//在葉子節點上加入元素數據
        {

            segt[root].mi=dat[st];//求區間最小值的操作

            return;
        }
        //對於非葉子節點
        int mid=(st+en)/2;//分割點
        //由二叉性，數組存樹的左右節點編號分別爲此節點的*2+1和*2+2
        build(dat,root*2+1,st,mid);//遞歸建左子樹
        build(dat,root*2+2,mid+1,en);//右子樹
        //由左右子樹得到此節點的數據
        //求區間最小值
        segt[root].mi=Max(segt[root*2+1].mi,segt[root*2+2].mi);
        //求區間和
        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;
    }


    int query_mi(int qst,int qen,int tst,int ten,int root)//查詢操作：向下遞歸的找區間，只要找到被要找的區間包括的區間，就可以肯定這個區間是需要的（因爲向下遞歸的順序和不交叉的順序）
    {//查詢最小值
        //qst,qen:想查詢的區間  tst,ten:正在查的區間

        if(qst>ten||qen<tst)//想查的區間和正在查區間的沒有重疊，剪枝
            return 0;
        if(tst>=qst&&ten<=qen)//正在查的區間比想查的小或者相等，符合
            return segt[root].mi;
        int mid =(tst+ten)/2;

        return Max(query_mi(qst,qen,tst,mid,root*2+1),query_mi(qst,qen,mid+1,ten,root*2+2));//搜索左右子樹
    }

    void adjust_elemt(const int addval,const int pos,int st,int en,int root)//點修改，給pos位置的元素加上addval
    {//思路：遞歸一遍，查找並修改需要修改的元素，然後把路徑更新一遍
        if(st==en)
        {
            if(st==pos)
            {//在這裏進行元素修改

                segt[root].mi=addval;//最大值

            }
            return;
        }
        int mid=(st+en)/2;
        if(pos<=mid)
        adjust_elemt(addval,pos,st,mid,root*2+1);
        else
        adjust_elemt(addval,pos,mid+1,en,root*2+2);
        //在這裏進行段修改
        segt[root].mi=Max(segt[root*2+1].mi,segt[root*2+2].mi);//最大值段修改

    }

    int main()
    {
        int xss,czs;
        while(~scanf("%d%d",&xss,&czs))
        {
            int arr[200005],cur;
            for(int i=0;i<xss;i++)
            {
                scanf("%d",&cur);
                arr[i]=cur;
            }
            build(arr,0,0,xss-1);
//for(int i=0;i<2*xss;i++)cout<<segt[i].mi<<" ";
            while(czs--)
            {
                char c[4];
                int st,en;
               scanf("%s",c);//cout<<"_____"<<c<<"______";
                if(c[0]=='Q')
                {
                    scanf("%d%d",&st,&en);
                    printf("%d\n",query_mi(st-1,en-1,0,xss-1,0));

                }
                else
                {
                    scanf("%d%d",&st,&en);
                    adjust_elemt(en,st-1,0,xss-1,0);
                   // for(int i=0;i<2*xss;i++)cout<<endl<<segt[i].mi<<" ";
                }
            }
        }






        return 0;
    }

2017.11.14

做題的時候發現模板前面的代碼寫的太爛，一方面是多餘的東西太多，一方面是段修改寫錯了敲打

拿hdu1698的代碼改改補個有段操作的新模板（點查詢還沒寫）（段最值操作也沒寫）

#include <cstdio>
#include<iostream>
    using namespace std;
    const int maxn=500100;
    struct segn
    {
        int su,mark_add;
    }segt[maxn];
   //下推的root是正在改的點的位置，st,en是這個點的區間
    void push_dowm_segadj(int root,int st,int en)//段加的下推
    {
        if(segt[root].mark_add!=0)
        {
            segt[root*2+1].su=((st+en)/2-st+1)*segt[root].mark_add;
            segt[root*2+2].su=(en-(st+en)/2)*segt[root].mark_add;
            segt[root*2+1].mark_add=segt[root].mark_add;
            segt[root*2+2].mark_add=segt[root].mark_add;
            segt[root].mark_add=0;
        }
    }
    void push_dowm_segadd(int root,int st,int en)//段賦值的下推
    {
        if(segt[root].mark_add!=0)
        {
            segt[root*2+1].su+=((st+en)/2-st+1)*segt[root].mark_add;
            segt[root*2+2].su+=(en-(st+en)/2)*segt[root].mark_add;
            segt[root*2+1].mark_add+=segt[root].mark_add;
            segt[root*2+2].mark_add+=segt[root].mark_add;
            segt[root].mark_add=0;
        }
    }
    void build(int *arr,int root,int st,int en)//arr:賦值數組 root,st寫0 en寫arr的長度-1
    {
        
        if(st==en)
        {
            segt[root].mark_add=0;
            segt[root].su=arr[st];
            return;
        }

        int mid=(st+en)/2;
        build(arr,root*2+1,st,mid);
        build(arr,root*2+2,mid+1,en);

        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;
    }


    void segadj(int qst,int qen,int tst,int ten,int root,int addnum)
    {//段賦值 q：查詢區間  t:正在搞的區間，寫0和n-1  addnum；改成的值

        if(qst>ten||qen<tst)//不符合的區間
            {
                return ;
            }
        if(tst>=qst&&ten<=qen)//找到要改的區間
            {
                segt[root].mark_add=addnum;
                segt[root].su=addnum*(ten-tst+1);
                return ;
            }
        int mid =(tst+ten)/2;
        push_dowm_segadj(root,tst,ten);
        segadj(qst,qen,tst,mid,root*2+1,addnum);
        segadj(qst,qen,mid+1,ten,root*2+2,addnum);//搜索左右子樹
    }
        void segadj(int qst,int qen,int tst,int ten,int root,int addnum)
    {//段修改 q：查詢區間  t:正在搞的區間，寫0和n-1  addnum；改成的值

        if(qst>ten||qen<tst)//不符合的區間
            {
                return ;
            }
        if(tst>=qst&&ten<=qen)//找到要加的區間
            {
                segt[root].mark_add=addnum;
                segt[root].su=addnum*(ten-tst+1);
                return ;
            }
        int mid =(tst+ten)/2;
        push_dowm_segadd(root,tst,ten);
        segadd(qst,qen,tst,mid,root*2+1,addnum);
        segadd(qst,qen,mid+1,ten,root*2+2,addnum);//搜索左右子樹
    }
    /*
    void upd(int root,int st,int en)//對於全部改完後才進行查詢的題，可以最後進行整體下推
    {
        if(st==en)return;
        push_dowm(root,st,en);//按需求改這個下推
        upd(2*root+1,st,(st+en)/2);
        upd(2*root+2,(st+en)/2+1,en);
        segt[root].su=segt[root*2+1].su+segt[root*2+2].su;
    }
    */





發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

這可能是最簡單的AVL二叉平衡查找樹講解

二叉平衡查找樹AVL詳解 看懂這篇文章所需的知識點 樹、二叉搜索樹、樹高、樹深、層等概念 AVL樹 概念：任意節點的左右子樹的高度差不能大於1的樹即爲AVL樹，是爲了解決在頻繁插入刪除等動態更新下出現的時間複雜度退化的問題，所以平

AD钙12138 2020-07-08 11:54:55

震驚！Redis 的字符串居然是這樣實現的…

雲棲號資訊：【點擊查看更多行業資訊】在這裏您可以找到不同行業的第一手的上雲資訊，還在等什麼，快來！ 之前本人在找工作面試時在Redis相關問題上可栽了跟頭。在面試前按常規套路準備了一下，比如 Redis 的常用5種數據結構，Redis持久化

雲棲號資訊小哥 2020-08-06 12:10:50

數據結構：AVL樹旋轉原理和簡易實現

AVL樹旋轉原理和簡易實現 二叉搜索樹雖然可以提高搜索效率，但是如果插入的數據有序時很有可能變成單支，如果變成單支樹的時候，那麼查找時效率也不高了。因此引入AVL樹。 AVL樹是當向這棵樹插入節點的時候，要保證每個節點的左右子樹的

ETalien_ 2020-07-08 12:19:01

數據結構：紅黑樹的旋轉原理和模擬實現

紅黑樹的旋轉原理和模擬實現 我們瞭解到AVL樹雖然效率很高，但是它是通過多次的旋轉纔到達一個絕對的平衡，旋轉的消耗其實也很大。因此開始引入近似平衡的一棵樹----紅黑樹（RBTree）。紅黑樹每一個節點不是紅色的就是黑色的，它保證

ETalien_ 2020-07-08 12:19:01

數據結構：大數據處理問題

1.給定100億個整數，設計算法找到只出現一次的整數？ ①方法一 100億個整數就是400億個字節，42億九千萬是4G，那麼1G就是10億字節，所以要存下100億個整數需要40G的內存空間。因此我們採用位圖100億個整數大概就是1

ETalien_ 2020-07-08 12:19:01

數據結構：布隆過濾器

布隆過濾器 假如現在有40億個ip地址（string類型），然後給你一個ip地址，讓你查找這個ip地址在不在這40億個ip地址裏？我們應該怎麼做呢？ 如果用哈希表來處理的話，這裏有40億的數據，數據量太大，因此太佔用空間 如果用

ETalien_ 2020-07-08 12:19:01

樹上剖分

————————————————18.4.18更新有時我們會遇到這樣的問題：在一棵樹上，每次詢問兩點間路徑上的和或者是最值。但我們用搜索時，時間就會到O（n），這樣根本就完不成算法。但樹上剖分就可以縮短修改的時間。樹上剖分的算法簡介我們定

蒟蒻午时已到 2020-07-08 11:59:23

2.7 封裝Request

  request作爲前後臺交換的橋樑，有重要作用。  request常用的方法有讀參數：public String getParameter(String paramName);讀取屬性public Object getAttribut

lws0888 2020-07-08 11:48:30

樹的總結（二）---非空二叉樹的高度和寬度

1.非空二叉樹的高度      1.1非遞歸算法實現求解非空二叉樹的高度  算法思想：採用層次遍歷的算法，設置變量level記錄當前結點所在的層數，設置變量last指向當前層的最右的結點，每次層次遍歷出隊的時候與last指針比較（fron

瞿颖Blog 2020-07-08 11:41:54

樹的總結（一）

考研加油！！！！！！！ 1.1樹的重要概念 1.樹是一種重要的非線性結構；在有n個結點的樹中有n-1條邊； 2.在結點個數爲n(n>1)的各棵樹中，深度最小的樹的深度是多少？它有多少葉子結點？多少分支結點？深度最大的樹的深度是多少？它有多

瞿颖Blog 2020-07-08 11:41:54

【劍指offer】題61：二叉樹序列化、反序列化

使用stringstream http://blog.csdn.net/xw20084898/article/details/21939811 stringstream 是 C++ 提供的另一個字串型的串流(stream)

xiaxzhou 2020-07-08 11:22:52

基本數據結構——線性結構（棧）

1.什麼是線性結構 線性結構是一種有序數據項的集合，其中每個數據項都有唯一的前驅和後繼（除了第一個沒有前驅，最後一個沒有後繼）。新的數據項加入到數據集中時，只會加入到原有某個數據項之前或之後。具有這種性質的數據集，就稱爲線性結構。

weixin_38324954 2020-07-08 11:06:52

Trie 前綴樹/字典樹

一、Trie的介紹：     1、主要應用場景：搜索引擎的自動補全功能：Trie樹+詞頻(概率)權重因子                                    IP路由：最長前綴匹配，Trie路由算法          

放羊的大飞 2020-07-08 10:58:58

數據結構——數組（3） 在有序數組中找出重複的次數最多的數

先總結有序數組，無序的後面再總結。。 1.以空間換時間法。 算法思想：目標數組array[length]，是一個有序數組，比如int array[]={1,1,2,2,4,4,4,4,4,5,5,6,10};總共有13個元素，

zhangying_496 2020-07-08 10:38:18

數據結構——數組（1）數組求和&打印二維數組&判斷數組是否遞增

數組求和 方法一：直接一次for循環 int GetSum1(int *a,int n) { int sum=0; for (int i=0; i<n;i++) { sum+=a[i];

zhangying_496 2020-07-08 10:38:18