线段树模板

最新推荐文章于 2024-10-11 21:43:15 发布

原创最新推荐文章于 2024-10-11 21:43:15 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线段树 #模板

模板专栏收录该内容

5 篇文章

订阅专栏

线段树

维护最长区间长度(HDU - 1540)

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 50005;
#define ls l,m,rt<<1
#define rs m+1,r,rt<<1|1
int n;
struct node
{
    int lmax, rmax, maxx;
    node(int _l,int _r,int _m):lmax(_l),rmax(_r),maxx(_m){}
    node(){}
}nodes[maxn << 2];
void build(int l, int r, int rt)
{
    nodes[rt] = node(r - l + 1, r - l + 1, r - l+1);
    if (l == r)return;
    int m = l + r >> 1;
    build(ls);
    build(rs);
}

void pushup(int rt,int ln,int rn)
{
    nodes[rt] = node(nodes[rt << 1].lmax, nodes[rt << 1 | 1].rmax, 0);
    nodes[rt].maxx = max(nodes[rt << 1].maxx, nodes[rt << 1 | 1].maxx);
    nodes[rt].maxx = max(nodes[rt].maxx, nodes[rt << 1].rmax + nodes[rt << 1 | 1].lmax);
    if (nodes[rt << 1].lmax == ln)
        nodes[rt].lmax = ln + nodes[rt << 1 | 1].lmax;
    if (nodes[rt << 1 | 1].rmax == rn)
        nodes[rt].rmax = rn + nodes[rt << 1].rmax;

}

void update(int L,int C, int l, int r, int rt)
{
    if (l == r)
    {
        if (C)
            nodes[rt] = node(1, 1, 1);
        else
            nodes[rt] = node(0, 0, 0);
        return;
    }
    int m = l + r >> 1;
    if (L <= m)
        update(L, C, ls);
    else
        update(L, C, rs);
    pushup(rt,m-l+1,r-m);
}

int query(int L, int l, int r, int rt)
{
    if (l == r || nodes[rt].maxx == r - l + 1 || nodes[rt].maxx == 0)
        return nodes[rt].maxx;
    int m = l + r >> 1;
    if (L <= m)
    {
        if (L >= m - nodes[rt << 1].rmax + 1)
            return query(L, ls) + query(m + 1, rs);
        else
            return query(L, ls);
    }
    else
    {
        if (L <= m+1 + nodes[rt << 1 | 1].lmax-1)
            return query(L, rs) + query(m, ls);
        else
            return query(L, rs);
    }
}


int main()
{
    int n, m;
    while (~scanf("%d %d", &n, &m))
    {
        build(1, n, 1);
        char s[3];
        int x;
        int stack[50005], tot = 0;
        for (int i = 1;i <= m;i++)
        {
            scanf("%s", s);
            if (s[0] == 'D')
            {
                scanf("%d", &x);
                stack[++tot] = x;
                update(x, 0, 1, n, 1);
            }
            else if (s[0] == 'Q')
            {
                scanf("%d", &x);
                printf("%d\n", query(x, 1, n, 1));
            }
            else
            {
                int tmp = stack[tot--];
                update(tmp, 1, 1, n, 1);
            }
        }
    }
    return 0;
}

扫描线求面积(HDU - 1542)

#include<iostream>
#include<algorithm>
using namespace std;
const int maxx = 100005;
const int maxn = 105;
#define ls l,m,rt<<1
#define rs m+1,r,rt<<1|1
struct line
{
    double l, r, h;
    int flag;
    line(double _l,double _r,double _h,int _f):l(_l),r(_r),h(_h),flag(_f){}
    line(){}
    bool operator<(const line &b)const
    {
        return h < b.h;
    }
}lines[maxn * 2];
double X[maxn * 2];
struct node
{
    int l, r;
    double len;
    int cnt;
    node(int _l, int _r, double _len, int _c) :l(_l), r(_r), len(_len), cnt(_c){}
    node(){}
}nodes[maxn << 3];
void build(int l, int r, int rt)
{
    nodes[rt] = node(l, r, 0.0, 0);
    if (l == r)return;
    int m = l + r >> 1;
    build(ls);
    build(rs);
}

void pushup(int rt)
{
    int lidx = nodes[rt].l, ridx = nodes[rt].r+1;
    if (nodes[rt].cnt)
        nodes[rt].len = X[ridx] - X[lidx];
    else if (nodes[rt].l == nodes[rt].r)
        nodes[rt].len = 0;
    else
        nodes[rt].len = nodes[rt << 1].len + nodes[rt << 1 | 1].len;
}

void update(int L, int R, int C, int l, int r,int rt)
{
    if (L <= l&&r <= R)
    {
        nodes[rt].cnt += C;
        pushup(rt);
        return;
    }
    int m = l + r >> 1;
    if (L <= m)update(L, R, C, ls);
    if (R > m)update(L, R, C, rs);
    pushup(rt);
}


int main()
{
    int n;
    int cas = 1;
    while (~scanf("%d",&n)&&n)
    {
        double x1, y1, x2, y2;
        int num = 0;
        int xnum = 0;
        for (int i = 1;i <= n;i++)
        {
            scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
            lines[num++] = line(x1, x2, y1, 1);
            lines[num++] = line(x1, x2, y2, -1);
            X[xnum++] = x1;
            X[xnum++] = x2;
        }
        sort(lines, lines + num);
        sort(X, X + xnum);
        xnum = unique(X, X + xnum)-X;
        build(0, xnum - 1, 1);
        double ans = 0;
        for (int i = 0;i < num-1;i++)
        {
            int lidx = lower_bound(X, X + xnum, lines[i].l) - X;
            int ridx = lower_bound(X, X + xnum, lines[i].r) - X;
            ridx--;
            update(lidx, ridx, lines[i].flag, 0, xnum - 1, 1);
            ans += nodes[1].len*(lines[i + 1].h - lines[i].h);
        }
        printf("Test case #%d\nTotal explored area: %.2f\n", cas++, ans);
        puts("");
    }

    return 0;
}

二维线段树

单点修改，区间查询极值问题(2013长春区域赛G题)

#include<iostream>
#include<algorithm>

using namespace std;
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define MAXN 805   ///大小
struct seg   /// 单点修改，区间查询极值模板
{
    int xL, xR, yL, yR, val;       /// 查询时xL,xR,yL,yR为边界，修改时(xL,yL)为修改点val为值
    int maxv, minv;
    int Max[MAXN << 2][MAXN << 2], Min[MAXN << 2][MAXN << 2];
    int N, mat[MAXN][MAXN];
    void init()
    {
        maxv = -(1 << 30);
        minv = 1 << 30;
    }
    void PushUp(int xrt, int rt)
    {
        Max[xrt][rt] = max(Max[xrt][rt << 1], Max[xrt][rt << 1 | 1]);
        Min[xrt][rt] = min(Min[xrt][rt << 1], Min[xrt][rt << 1 | 1]);
    }
    void BuildY(int xrt, int x, int l, int r, int rt)//x=-1的时候相当于BuildX的pushup函数，等于其他的就相当于初始化.同理后面的UpdateY也是一样的道理。
    {
        int m;
        if (l == r)
        {
            if (x != -1)Max[xrt][rt] = Min[xrt][rt] = mat[x][l];
            else
            {
                Max[xrt][rt] = max(Max[xrt << 1][rt], Max[xrt << 1 | 1][rt]);
                Min[xrt][rt] = min(Min[xrt << 1][rt], Min[xrt << 1 | 1][rt]);
            }
            return;
        }
        m = l + r >> 1;
        BuildY(xrt, x, lson);
        BuildY(xrt, x, rson);
        PushUp(xrt, rt);
    }

    void BuildX(int l, int r, int rt)
    {
        int m;
        if (l == r)
        {
            BuildY(rt, l, 1, N, 1);
            return;
        }
        m = l + r >> 1;
        BuildX(lson);
        BuildX(rson);
        BuildY(rt, -1, 1, N, 1);
    }
    void UpdateY(int xrt, int x, int l, int r, int rt)
    {
        int m;
        if (l == r)
        {
            if (x != -1)Max[xrt][rt] = Min[xrt][rt] = val;
            else
            {
                Max[xrt][rt] = max(Max[xrt << 1][rt], Max[xrt << 1 | 1][rt]);
                Min[xrt][rt] = min(Min[xrt << 1][rt], Min[xrt << 1 | 1][rt]);
            }
            return;
        }
        m = (l + r) >> 1;
        if (yL <= m)UpdateY(xrt, x, lson);
        else UpdateY(xrt, x, rson);
        PushUp(xrt, rt);
    }
    void UpdateX(int l, int r, int rt)
    {
        int m;
        if (l == r)
        {
            UpdateY(rt, l, 1, N, 1);
            return;
        }
        m = (l + r) >> 1;
        if (xL <= m)UpdateX(lson);
        else UpdateX(rson);
        UpdateY(rt, -1, 1, N, 1);
    }
    void QueryY(int xrt, int l, int r, int rt)
    {
        int m;
        if (yL <= l&&yR >= r)
        {
            minv = min(minv, Min[xrt][rt]);
            maxv = max(maxv, Max[xrt][rt]);
            return;
        }
        m = (l + r) >> 1;
        if (yL <= m)QueryY(xrt, lson);
        if (yR>m)QueryY(xrt, rson);
    }
    void QueryX(int l, int r, int rt)
    {
        int m;
        if (xL <= l&&xR >= r)
        {
            QueryY(rt, 1, N, 1);
            return;
        }
        m = (l + r) >> 1;
        if (xL <= m)QueryX(lson);
        if (xR>m)QueryX(rson);
    }
}Seg;
int main()
{
    int T;
    scanf("%d", &T);
    for (int cas = 1;cas <= T;cas++)
    {
        scanf("%d", &Seg.N);
        for (int i = 1;i <= Seg.N;i++)
            for (int j = 1;j <= Seg.N;j++)
                scanf("%d", &Seg.mat[i][j]);
        Seg.BuildX(1, Seg.N, 1);
        int Q;
        scanf("%d", &Q);
        printf("Case #%d:\n", cas);
        int L, x, y;
        while (Q--)
        {
            scanf("%d %d %d", &x, &y, &L);
            int length = (L - 1) / 2;
            Seg.xL = max(1, x - length);
            Seg.xR = min(Seg.N, x + length);
            Seg.yL = max(1, y - length);
            Seg.yR = min(Seg.N, y + length);
            Seg.init();
            Seg.QueryX(1, Seg.N, 1);
            int themax = Seg.maxv;
            int themin = Seg.minv;
            printf("%d\n", (themax + themin) / 2);
            Seg.val = (themax + themin) / 2;
            Seg.xL = x;
            Seg.yL = y;
            Seg.UpdateX(1, Seg.N, 1);
        }
    }
}