acwing算法提高课 线段树（2）

acwing算法提高课 线段树（2）

243. 一个简单的整数问题2

给定一个长度为 N 的数列 A，以及 M 条指令，每条指令可能是以下两种之一：

1. C l r d，表示把 A[l],A[l+1],…,A[r] 都加上 d。
2. Q l r，表示询问数列中第 l∼r 个数的和。

对于每个询问，输出一个整数表示答案。

输入格式

第一行两个整数 N,M。

第二行 N 个整数 A[i]。

接下来 M 行表示 M 条指令，每条指令的格式如题目描述所示。

输出格式

对于每个询问，输出一个整数表示答案。

每个答案占一行。

数据范围

1≤N,M≤10^5,
|d|≤10000,
|A[i]|≤10^9

输入样例：

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

输出样例：

4
55
9
15

243. 一个简单的整数问题2 题解

• 在之前的问题中，使用树状数组扩展完成了这道题，

• 本题同样是可以使用线段树来求解的

• 通过懒标记，实现对区间的修改，

• 修改时，如果当前节点区间完全被包含在提问区间内，直接打上懒标记，
  表示该节点的所有子节点都要加上tag(不包括当前节点)

• 同时，如果修改时没有完全包括当前节点，我们需要继续搜索他的左右儿子节点，
  在这之前，需要将懒标记下放(pushdown(u))，因为左右两边的区间所需要增加的tag可能是不一样的，

• 查询时，同样如此，如果包含了当前区间，直接返回，如果没有包含，先pushdown，再继续搜索左右子树

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

using namespace std;
typedef long long ll;

const int N = 1e5 + 10;

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

int a[N];
int n, m;


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

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

void build(int u, int l, int r){
    if(l == r){
        tr[u] = {l, r, 0, a[r]};
        return ;
    }
    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 c){
    if(tr[u].l >= l && tr[u].r <= r){
        tr[u].sum += (tr[u].r - tr[u].l + 1) * c;
        tr[u].tag += c;
        return ;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(l <= mid) modify(u << 1, l, r, c);
    if(mid < r) modify(u << 1 | 1, l, r, c);
    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(mid < r) sum += query(u << 1 | 1, l, r);
    return sum;
}

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++) scanf("%d", &a[i]);
    build(1, 1, n);
    
    for(int i = 1; i <= m; i ++){
        char op[2];
        int l, r, c;
        scanf("%s%d%d", op, &l, &r);
        if(op[0] == 'Q'){
            cout << query(1, l, r) << endl;
        }
        else {
            scanf("%d", &c);
            modify(1, l, r, c);
        }
    }
    return 0;
}

247. 亚特兰蒂斯

有几个古希腊书籍中包含了对传说中的亚特兰蒂斯岛的描述。

其中一些甚至包括岛屿部分地图。

但不幸的是，这些地图描述了亚特兰蒂斯的不同区域。

您的朋友 Bill 必须知道地图的总面积。

你自告奋勇写了一个计算这个总面积的程序。

输入格式

输入包含多组测试用例。

对于每组测试用例，第一行包含整数 n，表示总的地图数量。

接下来 n 行，描绘了每张地图，每行包含四个数字 x1,y1,x2,y2（不一定是整数），(x1,y1) 和 (x2,y2) 分别是地图的左上角位置和右下角位置。

注意，坐标轴 x 轴从上向下延伸，y 轴从左向右延伸。

当输入用例 n=0 时，表示输入终止，该用例无需处理。

输出格式

每组测试用例输出两行。

第一行输出 Test case #k，其中 k 是测试用例的编号，从 1 开始。

第二行输出 Total explored area: a，其中 a 是总地图面积（即此测试用例中所有矩形的面积并，注意如果一片区域被多个地图包含，则在计算总面积时只计算一次），精确到小数点后两位数。

在每个测试用例后输出一个空行。

数据范围

1≤n≤10000,
0≤x1<x2≤100000,
0≤y1<y2≤100000
注意，本题 n 的范围上限加强至 10000。

输入样例：

2
10 10 20 20
15 15 25 25.5
0

输出样例：

Test case #1
Total explored area: 180.00 

样例解释：

样例所示地图覆盖区域如下图所示，两个矩形区域所覆盖的总面积，即为样例的解。

题解

代码

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

using namespace std;

const int N = 1e4 + 10;

struct Segment{
    double x, y1, y2;
    int d;
    bool operator < (const Segment &t) const{
        return x < t.x;
    }
}seg[N << 1];

struct Node{
    int l, r;
    int cnt;//当前区间被覆盖次数
    double len;//当前区间长度
}tr[N << 3];//有n个方格，所以有2n个seg，最多8n个节点
vector<double> ys;
int n;

int find(double y){//离散化中的查询
    return lower_bound(ys.begin(), ys.end(), y) - ys.begin();
}

void pushup(int u){
    if(tr[u].cnt) tr[u].len = ys[tr[u].r + 1] - ys[tr[u].l];
    
    else if(tr[u].l != tr[u].r)
    {
        tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
    }
    else tr[u].len = 0;//表示为叶子节点且该线段没被覆盖，为无用线段，长度变为0
}

void modify(int u,int l,int r,int d)//表示从线段树中l点到r点的出现次数 + d
{
    if(tr[u].l >= l && tr[u].r <= r)//该区间被完全覆盖
    {
        tr[u].cnt += d;//该区间出现次数 + d
        pushup(u);//更新该节点的len
    }
    else
    {
        int mid = tr[u].r + tr[u].l >> 1;
        if (l <= mid)modify(u << 1,l,r,d);//左边存在点
        if (r > mid)modify(u << 1 | 1,l,r,d);//右边存在点
        pushup(u);//进行更新
    }
}


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

int main(){
    int T = 0;
    while(scanf("%d",&n), n){
        
        ys.clear();
        int j = 0;
        for(int i = 0; i < n; i ++){
            double x1, y1, x2, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            seg[j ++] = {x1, y1, y2, 1};
            seg[j ++] = {x2, y1, y2, -1};
            ys.push_back(y1); ys.push_back(y2);
        }
        
        sort(seg, seg + j);
        sort(ys.begin(), ys.end());
        
        ys.erase(unique(ys.begin(), ys.end()), ys.end());//离散化去重
        // for(int i = 0; i < ys.size(); i ++) cout << ys[i] << endl;
        build(1, 0, ys.size() - 2);
        
        double res = 0;
        for(int i = 0; i < j; i ++){
            if(i) res += tr[1].len * (seg[i].x - seg[i - 1].x);
            // cout << find(seg[i].y1) << " " << find(seg[i].y2) - 1 << endl;
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1,seg[i].d);
        }
        
        printf("Test case #%d\n", ++ T);
        printf("Total explored area: %.2lf\n\n", res);
    }
    return 0;
}

1277. 维护序列

老师交给小可可一个维护数列的任务，现在小可可希望你来帮他完成。

有长为 N 的数列，不妨设为 a1,a2,…,aN。

有如下三种操作形式：

1. 把数列中的一段数全部乘一个值；
2. 把数列中的一段数全部加一个值；
3. 询问数列中的一段数的和，由于答案可能很大，你只需输出这个数模 P 的值。

输入格式

第一行两个整数 N 和 P；

第二行含有 N 个非负整数，从左到右依次为 a1,a2,…,aN；

第三行有一个整数 M，表示操作总数；

从第四行开始每行描述一个操作，输入的操作有以下三种形式：

1. 操作 1：1 t g c，表示把所有满足 t≤i≤g 的 ai 改为 ai×c；
2. 操作 2：2 t g c，表示把所有满足 t≤i≤g 的 ai 改为 ai+c；
3. 操作 3：3 t g，询问所有满足 t≤i≤g 的 ai 的和模 P 的值。

同一行相邻两数之间用一个空格隔开，每行开头和末尾没有多余空格。

输出格式

对每个操作 3，按照它在输入中出现的顺序，依次输出一行一个整数表示询问结果。

数据范围

1≤N,M≤10^5,
1≤t≤g≤N,
0≤c,ai≤10^9,
1≤P≤10^9

输入样例：

7 43
1 2 3 4 5 6 7
5
1 2 5 5
3 2 4
2 3 7 9
3 1 3
3 4 7

输出样例：

2
35
8

样例解释：
无

1277. 维护序列 题解

本题修改区间时，不仅仅时对区间内所有数 + k，也可能对区间内所有数 * k

所以设置Node{
    int l, r;//区间左右节点
    int sum;//区间和
    int add;//加法懒标记
    int mul;//乘法懒标记
}

• 假设某节点 区间和为sum1, 有懒标记add1 和 mul1
  那么这个区间最终的结果为 sum1 * mul1 + add

• 此时需要父节点pushdown，需要更新当前节点的add1和mul1,父节点下放add2, mul2

• 最终结果为 (sum1 * mul1 + add1) * mul1 + add2

• 展开为 sum1 * (mul1 *mul2) + (add1 * mul1 + add2)

• 那么新的mul = mul1 * mul2 和 新的add = add1 * mul1 + add2

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

using namespace std;
typedef long long ll;

const int N = 1e5 + 10;

int n, m, p;
struct Node{
    int l, r;
    int sum, add, mul;
}tr[N << 2];
int a[N];

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

void eval(Node &t, int add, int mul){
    t.sum = ((ll)t.sum * mul + (ll)(t.r - t.l + 1) * add) % p;
    t.mul = ((ll)t.mul * mul) % p;
    t.add = ((ll)t.add * mul + add) % p;
}

void pushdown(int u){
    eval(tr[u << 1], tr[u].add, tr[u].mul);
    eval(tr[u << 1 | 1], tr[u].add, tr[u].mul);
    tr[u].add = 0;
    tr[u].mul = 1;
}


void build(int u, int l, int r){
    if(l == r){
        tr[u] = {l, r, a[r], 0, 1};
        return ;
    }
    tr[u] = {l, r, 0, 0, 1};
    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 add, int mul){
    if(tr[u].l >= l && tr[u].r <= r){
        eval(tr[u], add, mul);
        return ;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(l <= mid) modify(u << 1, l, r, add, mul);
    if(mid < r) modify(u << 1 | 1, l, r, add, mul);
    pushup(u);
}

int 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;
    int res = 0;
    if(l <= mid) res = query(u << 1, l, r);
    if(mid < r) res = (res + query(u << 1 | 1, l, r)) % p;
    return res;
}

int main(){
    scanf("%d%d", &n, &p);
    for(int i = 1; i <= n; i ++) scanf("%d", &a[i]);
    
    build(1, 1, n);
    scanf("%d", &m);
    for(int i = 1; i <= m; i ++){
        int t, a, b, c;
        scanf("%d%d%d", &t, &a, &b);
        if(t == 3){
            printf("%d\n", query(1, a, b));
        }
        else if(t == 1){
            scanf("%d", &c);
            modify(1, a, b, 0, c);
        }
        else {
            scanf("%d", &c);
            modify(1, a, b, c, 1);
        }
    }
    return 0;
}