kuangbin专题线段树

最新推荐文章于 2023-09-25 16:06:34 发布
最新推荐文章于 2023-09-25 16:06:34 发布
阅读量200 收藏
点赞数 1
分类专栏： 算法竞赛 文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/exercise_smile/article/details/120608329
版权

HDU 1166 敌兵布阵

思路

线段树单点修改模板

代码

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;

const int N = 50010;

struct Node {
    int l, r;
    int sum;
} tr[N * 4];

int w[N];

void pushup(int u) {
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void build(int u, int l, int r) {
    if(l == r) {
        tr[u] = {l, l, w[l]};
    }    
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, int v) {
    if (tr[u].l == x && tr[u].r == x) {
        tr[u].sum += v;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid)
            modify(u << 1, x, v);
        else
            modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

int query(int u, int l, int r) {
    if(tr[u].l >= l && tr[u].r <= r)
        return tr[u].sum;
    else {
        int sum = 0;
        int mid = tr[u].l + tr[u].r >> 1;
        if(l <= mid)
            sum += query(u << 1, l, r);
        if(r > mid)
            sum += query(u << 1 | 1, l, r);
        return sum;
    }
}

int main() {
    int T;
    scanf("%d", &T);
    int id = 0;
    while(T --) {
        printf("Case %d:\n", ++id);
        int n;
        scanf("%d", &n);
        for (int i = 1; i <= n; i ++)
            scanf("%d", &w[i]);
        build(1, 1, n);
        string op;
        int l, r;
        while(cin >> op , op != "End") {
            scanf("%d%d", &l, &r);
            if(op[0] == 'A')
                modify(1, l, r);
            else if(op[0] == 'S')
                modify(1, l, -r);
            else
                printf("%d\n", query(1, l, r));
        }
    }

    return 0;
}

HDU 1754 I hate it

思路

线段树单点修改模板

代码

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 200010;

struct Node {
    int l, r;
    int v;
} tr[N * 4];

int w[N];

void pushup(int u) {
    tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}

void build(int u, int l, int r) {
    if(l == r) {
        tr[u] = {l, r, w[l]};
    }
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, int val) {
    if(tr[u].l == x && tr[u].r == x) {
        tr[u].v = val;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid)
            modify(u << 1, x, val);
        else
            modify(u << 1 | 1, x, val);
        pushup(u);
    }
}

int query(int u, int l, int r) {
    if(tr[u].l >= l && tr[u].r <= r)
        return tr[u].v;
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        int maxx = 0;
        if(l <= mid)
            maxx = query(u << 1, l, r);
        if(r > mid)
            maxx = max(maxx, query(u << 1 | 1, l, r));
        return maxx;
    }

} 

int main() {
    int n, m;
    while(~scanf("%d%d", &n, &m)) {
        for (int i = 1; i <= n; i ++)
            scanf("%d", &w[i]);
        build(1, 1, n);

        while(m --) {
            char op[2];
            int l, r;
            scanf("%s%d%d", op, &l, &r);
            if(op[0] == 'U') {
                modify(1, l, r);
            }
            else {
                printf("%d\n", query(1, l, r));
            }
        }
    }

    return 0;
}

POJ 3468 A Simple Problem with Integers

思路

线段树区间修改区间查询模板

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>

using namespace std;

const int N = 100010;

typedef long long LL;

struct Node {
    int l, r;
    LL sum, add;
} tr[N * 4];

int w[N];


void pushup(int u) {
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void pushdown(int u){
    if(tr[u].add) {
        tr[u << 1].add += tr[u].add, tr[u << 1].sum += (LL)(tr[u << 1].r - tr[u << 1].l + 1) * tr[u].add;
        tr[u << 1 | 1].add += tr[u].add, tr[u << 1 | 1].sum += (LL)(tr[u << 1 | 1].r - tr[u << 1 | 1].l + 1) * tr[u].add;
        tr[u].add = 0;
        }
}

void build(int u, int l, int r) {
    if(l == r)
        tr[u] = {l, l, w[l], 0};
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int l, int r, int d) {
    if(tr[u].l >= l && tr[u].r <= r) {
        tr[u].sum += (LL)(tr[u].r - tr[u].l + 1) * d;
        tr[u].add += d;
    }
    else {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if(l <= mid)
            modify(u << 1, l, r, d);
        if(r > mid)
            modify(u << 1 | 1, l, r, d);
        pushup(u);
    }
}

LL query(int u, int l, int r) {
    if(tr[u].l >= l && tr[u].r <= r){
        return tr[u].sum;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL sum = 0;
    if(l <= mid)
        sum += query(u << 1, l, r);
    if(r > mid)
        sum += query(u << 1 | 1, l, r);
    return sum;
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++) {
        scanf("%d", &w[i]);
    }

    build(1, 1, n);

    while(m --) {
        char op[2];
        int l, r;
        scanf("%s%d%d", op, &l, &r);
        if(op[0] == 'Q') {
            printf("%lld\n", query(1, l, r));
        }
        else {
            int c;
            scanf("%d", &c);
            modify(1, l, r, c);
        }
    }

    return 0;
}

POJ - 2528 Mayor’s posters

思路

借鉴作者: verden
对区间操作，即对区间进行染色，线段树
不过此题数据范围较大，需要用到保序离散化。
注意离散化的时候，当两个点的距离大于1，需要新增一个点。

原因：[1,10],[1,4],[4,6]
离散化为:[1,4],[1,2] ,[3, 4]
区间查询的时候只会查询到两种颜色

  • pushdown的时候，如果当前区间是同一种颜色（懒标记是1），这个区间存储的color有意义，需要传给left和right，把left和right的懒标记置为1（表示当前整个区间是同一种颜色）
  • 在query时，如果当前区间的懒标记是1就可以把color插入结果，直接返回，否则一直查询到子节点

代码

#include<iostream>
#include<cstring>
#include<algorithm>
#include<set>
#include<vector>
#define rep(i, a, b) for (int i = a; i <= b; i ++)
#define x first
#define y second
using namespace std;

typedef pair<int, int> PII;
const int N = 1e4 + 100;

int n;
vector<int> v;
set<int> s;
PII a[N];
struct Node {
	// color,该区间的颜色
    int l, r, col;
    // 对标记的理解：父亲修改，儿子暂时尚未修改, 减少所有节点都更新的开销
    bool flag; // 懒标记：当前区间是否是同一种颜色
} tr[N << 4];

// 多组数据初始化
void init() {
    s.clear();
    v.clear();
}

void build(int u, int l, int r) {
    tr[u] = {l, r, 0, 1};
    if(l != r) {
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    }
}

// 对pushdown的理解：当要对儿子操作或者查询，需要进行修改，并把标记传下去
void pushdown(int u) {
    Node &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if(root.flag) {
        left.flag = right.flag = 1;
        left.col = right.col = root.col;
        root.flag = 0;
    }
}

void modify(int u, int l, int r, int color) {
    if(tr[u].l >= l && tr[u].r <= r) {
        tr[u].col = color;
        tr[u].flag = 1;
    }
    else {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if(l <= mid)
            modify(u << 1, l, r, color);
        if(r > mid)
            modify(u << 1 | 1, l, r, color);
    }
}

void query(int u, int l, int r) {
    if(tr[u].l == tr[u].r || tr[u].flag) {
        if(tr[u].col) {
            s.insert(tr[u].col);
        }
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if(l <= mid)
            query(u << 1, l, r);
        if(r > mid)
            query(u << 1 | 1, l, r);
    }
}

int main() {
    int T;  
    cin >> T;
    while(T --) {
        cin >> n;
        init();
        rep(i, 1, n) {
            cin >> a[i].x >> a[i].y;
            v.push_back(a[i].x);
            v.push_back(a[i].y);
        }

        sort(v.begin(), v.end());
        int Size = v.size();
        // 加点
        rep(i, 1, Size - 1) 
            if(v[i] - v[i - 1] > 1) {
                v.push_back(v[i - 1] + 1);
            }   
        // 离散化
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());

        build(1, 1, v.size());

        rep(i, 1, n) {
            a[i].x = lower_bound(v.begin(), v.end(), a[i].x) - v.begin() + 1; // 偏移1个位置
            a[i].y = lower_bound(v.begin(), v.end(), a[i].y) - v.begin() + 1; // 偏移1个位置
            modify(1, a[i].x, a[i].y, i);
        }

        query(1, 1, v.size());

        cout << s.size() << endl;
    }
}

HDU - 1698 Just a Hook

思路

区间修改的模板题。
(为什么每次调试的时候我都忘了把N该回来了！！！牢记)

代码

#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 100010;

typedef long long LL;

struct Node {
    int l, r;
    int sum;
    int lazy;
} tr[N << 2];

void pushdown(int u) {
    Node &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if(root.lazy) {
        left.lazy = root.lazy, left.sum = (LL)(left.r - left.l + 1) * root.lazy;
        right.lazy = root.lazy, right.sum = (LL)(right.r - right.l + 1) * root.lazy;
        root.lazy = 0;
    }
}

void pushup(int u) {
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void build(int u, int l, int r) {
    if(l == r)
        tr[u] = {l, l, 1, 0};
    else {
        tr[u] = {l, r};
        tr[u].lazy = 0;
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int l, int r, int x) {
    if(tr[u].l >= l && tr[u].r <= r) {
        tr[u].sum = (LL)(tr[u].r - tr[u].l + 1) * x;
        tr[u].lazy = x;
    }
    else {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if(l <= mid)
            modify(u << 1, l, r, x);
        if(r > mid)
            modify(u << 1 | 1, l, r, x);
        pushup(u);
    }
}

int query(int u, int l, int r){
    if(tr[u].l >= l && tr[u].r <= r) {
        return tr[u].sum;
    }
    else {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        int sum = 0;
        if(l <= mid)
            sum += query(u << 1, l, r);
        if(r > mid)
            sum += query(u << 1 | 1, l, r);
        return sum;
    }
}

int main(){
    int T;
    scanf("%d", &T);
    int id = 0;

    while(T --) {
        int n;
        scanf("%d", &n);

        build(1, 1, n);

        int q;
        scanf("%d", &q);
        while(q --) {
            int l, r, val;
            scanf("%d%d%d", &l, &r, &val);
            modify(1, l, r, val);
        }

        printf("Case %d: The total value of the hook is %d.\n", ++id, query(1, 1, n));
    }

    return 0;
}

POJ - 3264 Balanced Lineup

题意：

多次询问区间的最大值和最小值的差

思路

这题用ST表直接过，也是板子

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdio>


using namespace std;

const int N = 50010, M = 16;
int f1[N][M], f2[N][M];
int w[N];
int n, m;

void init() {
    for (int j = 0; j < M; j ++)
        for (int i = 1; i + (1 << j) - 1 <= n; i ++) {
            if(!j)
                f1[i][j] = w[i];
            else {
                f1[i][j] = max(f1[i][j - 1], f1[i + (1 << j - 1)][j - 1]);
            }
        }

    for (int j = 0; j < M; j ++)
        for (int i = 1; i + (1 << j) - 1 <= n; i ++) {
            if(!j)
                f2[i][j] = w[i];
            else {
                f2[i][j] = min(f2[i][j - 1], f2[i + (1 << j - 1)][j - 1]);
            }
        }
}

int query(int l, int r) {
    int len = r - l + 1;
    int k = log(len) / log(2);

    int maxx = max(f1[l][k], f1[r - (1 << k) + 1][k]);
    int minx = min(f2[l][k], f2[r - (1 << k) + 1][k]);

    return maxx - minx;
}

int main()
{
    while(~scanf("%d%d", &n, &m)) {
        for (int i = 1; i <= n; i ++)
            scanf("%d", &w[i]);
        init();
        while(m --) {
            int l, r;
            scanf("%d%d", &l, &r);
            int ans = query(l, r);
            printf("%d\n", ans);
        }
    }

    return 0;
}

HDU - 4027 Can you answer these queries?

题意

区间修改：将区间内所有数开根号，向下取整
区间查询：求区间内和

思路

因为一个数最大是2^63,最多会开根号开6次，该值就变为1了，所以对区间开根号的时候，可以将区间的所有点依次开根号，即对单点操作，不会超时

代码

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>

using namespace std;

const int N = 100010;

typedef long long LL;

struct Node {
    int l, r;
    LL sum;
} tr[N * 4];

LL w[N];

void pushdown(int u) {
    tr[u].sum = sqrt(tr[u].sum);
}
void pushup(int u) {
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void build(int u, int l, int r) {
    if(l == r) {
        tr[u] = {l, l, w[l]};
    }
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int l, int r) {
    if(tr[u].r - tr[u].l + 1 == tr[u].sum)
        return;
    if(tr[u].l == tr[u].r) {
        pushdown(u);
        return;
    }

    int mid = tr[u].l + tr[u].r >> 1;
    if(l <= mid)
        modify(u << 1, l, r);
    if(r > mid)
        modify(u << 1 | 1, l, r);
    pushup(u);
}

LL query(int u, int l, int r) {
    if(tr[u].l >= l && tr[u].r <= r)
        return tr[u].sum;
    else {
        LL mid = tr[u].l + tr[u].r >> 1;
        LL sum = 0;
        if(l <= mid)
            sum += query(u << 1, l, r);
        if(r > mid)
            sum += query(u << 1 | 1, l, r);
        return sum;
    }  
}

int main() {
    LL n;
    int id = 0;
    while(~scanf("%lld", &n)) {
        printf("Case #%d:\n", ++id);
        for (int i = 1; i <= n; i ++)
            scanf("%lld", &w[i]);

        build(1, 1, n);

        LL m;
        scanf("%lld", &m);
        while(m --) {
            LL op, l, r;
            scanf("%lld%lld%lld", &op, &l, &r);
            if(l > r)
                swap(l, r);
            if(!op)
                modify(1, l, r);
            else {
                printf("%lld\n", query(1, l, r));
            }
        }
        printf("\n");
    }

    return 0;
}

HDU 1540 Tunnel Warfare

题意

一个长度为n的序列初始值都为1
给定3个操作

  • 单点修改，把某点改为0
  • 单点修改，把最近被修改为0的点 修改成1
  • 区间查询，查询该点所在位置能构成最长的连续1的个数

思路

维护改区间最大连续1前缀lmax，最大连续1后缀rmax，最大连续ltmax

如何查询？

该点在一个特定区间root区间内，查询该点在该区间的最长连续1的个数。

先判断 该点具体在左半区left，还是在右半区 right。
我们先只考虑假如该点具体在左半区left区间的情况。

如果left区间的rmax比从x位置到left区间的末尾还要大,说明从x位置开始后半段加上x的前小段都是1，并且甚至可以跨区间到right区间的前缀1.
所以return tr[u << 1].rmax + tr[u << 1 | 1].lmax 即可

否则的话，就继续对左区间递归查询。

若该点在右半区区间的话同理。

代码

#include<cstring>
#include<algorithm>
#include<iostream>

using namespace std;

const int N = 50010;

struct Node {
    int l, r;
    // 这sum可不加，因为权值是0，1，可直接算
    // 最大连续1前缀，最大后缀，最大连续
    int lmax, rmax, tmax;
} tr[N << 2];
int n, m;
int top, stk[N];

void pushup(int u) {
    Node &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    int mid = root.l + root.r >> 1;
    root.lmax = left.lmax + (left.lmax == mid - root.l + 1 ? right.lmax : 0);
    root.rmax = right.rmax + (right.rmax == root.r - mid ? left.rmax : 0);
    root.tmax = max(max(left.tmax, right.tmax), left.rmax + right.lmax);
}

void build(int u, int l, int r) {
    if(l == r) {
        tr[u] = {l, r, 1, 1, 1};
    }
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }

}

void modify(int u, int x, int v) {
    if (tr[u].l == tr[u].r) {
        tr[u].tmax = tr[u].lmax = tr[u].rmax = v;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid)
            modify(u << 1, x, v);
        else
            modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

int query(int u, int x) {
    if(tr[u].tmax == 0 || tr[u].l == tr[u].r){
        return tr[u].tmax;
    }
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid) {
            if(mid - x + 1 <= tr[u << 1].rmax) {
                return tr[u << 1].rmax + tr[u << 1 | 1].lmax;
            }
            else
                return query(u << 1, x);
        }
        else {
            if(x - mid <= tr[u << 1 | 1].lmax) {
                return tr[u << 1].rmax + tr[u << 1 | 1].lmax;
            }
            else
                return query(u << 1 | 1, x);
        }
    }
}

int main() {
    while(~scanf("%d%d", &n, &m)) {
        build(1, 1, n);
        top = 0;
        for (int i = 1; i <= m; i ++) {
            char op[2];
            int x;
            scanf("%s", op);
            if(op[0] == 'D') {
                scanf("%d", &x);
                stk[++ top] = x;
                modify(1, x, 0);
            }
            else if(op[0] == 'Q') {
                scanf("%d", &x);
                printf("%d\n", query(1, x));
            }
            else
                modify(1, stk[top--], 1);
        }
    }

    return 0;
}
朴素先生在进步
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin专题七线段树总结
qq_34921856的博客
02-28 328
总结:线段树最重要的就是pushup和pushdown两个函数。此外，根据题目需要，要清楚自己要维护的东西。 D - Mayor’s posters 这一题，首先x的范围很大，所以要先离散化，离散化之后，每两个点之间如果坐标值之差大于1的话，他们中间还得插一个值。否则的话，读者可以试试这组数据 3 5 6 4 5 6 8 如果没有插的话就会输出2了。 线段树维护区间是否被填满。...
[kuangbin带你飞] 专题一 简单搜索 题解（超详细注释，史上最强题解）
m0_60962081的博客
05-20 4347
[kuangbin带你飞] 专题一 简单搜索 题解（超详细注释，史上最强题解）
kuangbin带你飞专题
热门推荐
邵光亮的博客
09-17 14万+
[kuangbin带你飞]专题一 简单搜索 [kuangbin带你飞]专题二 搜索进阶 [kuangbin带你飞]专题三 Dancing Links [kuangbin带你飞]专题四 最短路练习 [kuangbin带你飞]专题五 并查集 [kuangbin带你飞]专题六 最小生成树 [kuangbin带你飞]专题七 线段树 [kuangbin带你飞]专题八 生成树 [ku...
基础搜索（kuangbin专题）
qq_51537972的博客
10-12 659
目录棋盘问题 （POJ-1321）Dungeon Master （POJ-2251）Catch That Cow (POJ-3278)Fliptile （POJ-3279） 棋盘问题 （POJ-1321） 题目链接：传送门 题意：给定一个n*n的不规则棋盘，要求放入k个棋子，其中“#”能放棋子，“.”空白不能放棋子，且对于已经放了的棋子不能再放入同一行、同一列，求出有多少种放棋子的方案 其实不难，就是一个深度遍历加上回溯 #ifndef _GLIBCXX_NO_ASSERT #include <cas
“kuangbin带你飞”专题计划——专题十六 KMP & 扩展KMP & Manacher
I_have_a_world的博客
08-26 306
目录前言题目（kmp算法实际应该称为前缀函数算法）1. Number Sequence HDU - 1711 （KMP模板题：在另一个字符串中找一个字符串出现的位置）2. Oulipo HDU - 1686 （KMP模板题：求一个子串在另一个子串中出现的次数）3. 剪花布条 HDU - 2087 （KMP模板题：求另一个字符串中最多可以在剪出多少个该字符串）4. Cyclic Nacklace HDU - 3746 （前缀函数模板题：求字符串周期n-pi[n-1]）5. Period HDU - 1358
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
09-19
1. **基础数据结构**：线性结构（如数组、链表）、树结构（如二叉树、平衡树）、图结构（如邻接矩阵、邻接表）等。这些数据结构在ACM比赛中常常被用来处理问题，例如搜索、排序、最短路径等。 2. **排序与查找算法*...
kuangbin的ACM模板（新）_模板_kuangbin_kuangbinacm_ACM_
09-29
在ACM竞赛中，图论问题常见于最小生成树（如Prim算法或Kruskal算法）、最短路径（Dijkstra算法、Floyd-Warshall算法等）、强连通分量识别、寻找桥和割点等。这些概念和算法对于解决复杂网络问题有着至关重要的作用。...
专题七 线段树（kuangbin专题）（还有扫描线的题待补充）
最新发布
m0_74911187的博客
09-25 49
单点修改 + 区间查询: 1 2 9区间修改 + 区间查询: 3 5 8 10 11 12 13区间染色: 4 6需要合并区间的区间查询: 7扫描线计算面积: 16 15扫描线计算周长: 14扫面线计算体积: 17。
kuangbin——线段树专题 H - Tunnel Warfare
你那么爱笑，家里人知道吗？
08-05 2817
H - Tunnel Warfare Time Limit:2000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description During the War of Resistance Against Japan, tunnel warfare w
线段树复习--[kuangbin带你飞] 线段树
hi_just_do_it的博客
07-11 502
温故知新，现在代码水平好了一些，重新刷kuangbin的专题也不那么费劲了。争取理解的透彻一些吧。区间更新模板：LL num[maxn],sum[maxn<<2],mark[maxn<<2];void push_up(int root) { sum[root] = sum[root<<1]+sum[root<<1|1]; } void push_down(int root,int cl,in
kuangbin带你飞系列目录与简介
Izayoi_w的博客
08-05 1万+
kuangbin带你飞系列是由ACM圈内的一个菊苣，上海大学的邝斌（现已研究生毕业，就职于谷歌），在vjudge平台上建立的一个题目系列，从最简单的暴力搜索，到各种高深的算法与数据结构，几乎无所不包，这一套刷下来对于每一位打ACM的人来说都将是一次水平的飞跃。 目录链接：https://cn.vjudge.net/article/187 题目分级及建议顺序链接：ACM 的正确入门方式是什么？ ...
kuangbin专题七 线段树【从入门到熟练】【13题】
weixin_30273501的博客
10-14 104
【POJ 2528 Mayor's posters】 每个海报会覆盖一段连续的区间，所以这是个区间覆盖问题，可以用线段树。 但硬上nlogm虽然不会tle，但会mle，所以要离散化。 在[1,10000000]的这个瓷砖里，只有10000级别的修改，我们可以想象出整个区间可以被划分为多个被cover情况【一致】的小区间。那什么样的小区间被cover情况一致呢，所有端点排序后相邻端点构成的区间...
kuangbin专题 专题1 简单搜索
YeYuShengFan_的博客
06-12 184
kuangbin专题
“kuangbin带你飞”专题计划——专题六：最小生成树（MST）
I_have_a_world的博客
04-07 155
系统学习总结最小生成树 ...
kuangbin专题十四数论基础总结
qq_34921856的博客
04-02 431
做完感觉数论好像还没入门。。感觉并不基础。。 A - Bi-shoe and Phi-shoe A题当时wa了好多次，做的时候逻辑出现了错误，只是将求出来的欧拉值和数字(pair)排了个序，然后找出第一个欧拉值大于等于它的那个数，但这样并不正确，因为有可能后面有欧拉值比他更大的但值更小的。 之后我的做法是维护一个1到当前数欧拉值的最大值，这样使得从1到n的first也是一个递增序列，从而可以...
【kuangbin专题一】简单搜索 （完整）
UPUP&TOPTOP
06-24 378
1. poj 1321 棋盘排列 类似八皇后 /* poj 1321 棋盘排列 类似八皇后的排列搜索。 */ #include <iostream> #include <cstdio> #include <cstring> using namespace std; typedef long long ll; int dp[11][11]; cha...
算法模板1
08-08
算法模板-XMH1,线段树color the ball2,树状数组，color the ball3,DFS求连通块4,FFT-kuangbin模板-两数相乘5,

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值