洛谷 P2184 贪婪大陆-CSDN博客

洛谷 P2184 贪婪大陆

Description

小FF最后一道防线是一条长度为N的战壕，小FF拥有无数多种地雷，而SCV每次可以在[ L , R ]区间埋放同一种不同于之前已经埋放的地雷。由于情况已经十万火急，小FF在某些时候可能会询问你在[ L' , R'] 区间内有多少种不同的地雷，他希望你能尽快的给予答复。

对于30%的数据： 0<=n, m<=1000;

对于100%的数据： 0<=n, m<=10^5.

Input

第一行为两个整数n和m； n表示防线长度， m表示SCV布雷次数及小FF询问的次数总和。

接下来有m行，每行三个整数Q，L , R；若Q=1 则表示SCV在[ L , R ]这段区间布上一种地雷，若Q=2则表示小FF询问当前[ L , R ]区间总共有多少种地雷。

Output

对于小FF的每次询问，输出一个答案（单独一行），表示当前区间地雷总数。

Sample Input

5 4
1 1 3
2 2 5
1 2 4
2 3 5

Sample output

1

2

题解：

数据结构题（线段树）
这题再一次告诉了我线段树的灵活。记住，线段树不是一种算法，而是一种数据结构。是用来维护区间的，至于怎么维护，要结合题意。这题求的是种类。所以如果维护和/最值肯定不行。所以要换一种思路。对于每次给出的埋地雷区间[l, r]，l为开始标记，r为结束标记。开两个线段树，分别在l和r单点修改。最后区间[l, r]的结果就是1-r的开始标记个数 - 1-(l - 1)的结束标记个数。
下面举个例子，如图：

红色为开始标记，绿色为结束标记。
首先查询1-r的开始标记个数，意味着有这么多个地雷
然后查询1-(l - 1)的结束标记个数，意味着到查询区间之前已经有两种地雷埋完了
为什么不查查询区间里的结束标记，因为如果在查询区间里结束，地雷区间还是覆盖到了一部分的查询区间
这道题挺巧妙的，需要反复琢磨

#include <iostream>
#include <cstdio>
#define maxn 100005
using namespace std;

struct Tree {int l, r, val, tag;} tree1[maxn * 4], tree2[maxn * 4];
int n, m;

int read()
{
    int x = 0; char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') {x = x * 10 + c - '0'; c = getchar();}
    return x;
}

void build(int root, int l, int r)
{
    tree1[root].l = tree2[root].l = l, tree1[root].r = tree2[root].r = r;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(root << 1, l, mid), build(root << 1 | 1, mid + 1, r);
}

void down1(int root)
{
    int son1 = root << 1, son2 = root << 1 | 1;
    tree1[son1].tag += tree1[root].tag, tree1[son2].tag += tree1[root].tag;
    tree1[son1].val += (tree1[son1].r - tree1[son1].l + 1) * tree1[root].tag;
    tree1[son2].val += (tree1[son2].r - tree1[son2].l + 1) * tree1[root].tag;
    tree1[root].tag = 0;
}

void down2(int root)
{
    int son1 = root << 1, son2 = root << 1 | 1;
    tree2[son1].tag += tree2[root].tag, tree2[son2].tag += tree2[root].tag;
    tree2[son1].val += (tree2[son1].r - tree2[son1].l + 1) * tree2[root].tag;
    tree2[son2].val += (tree2[son2].r - tree2[son2].l + 1) * tree2[root].tag;
    tree2[root].tag = 0;
}

void update1(int root, int l, int r, int add)
{
    if(tree1[root].l >= l && tree1[root].r <= r)
    {
        tree1[root].tag += add;
        tree1[root].val += (tree1[root].r - tree1[root].l + 1) * add;
        return;
    }
    if(tree1[root].tag) down1(root);
    int mid = (tree1[root].l + tree1[root].r) >> 1;
    if(l <= mid) update1(root << 1, l, r, add);
    if(r > mid) update1(root << 1 | 1, l, r, add);
    tree1[root].val = tree1[root << 1].val + tree1[root << 1 | 1].val;
}

void update2(int root, int l, int r, int add)
{
    if(tree2[root].l >= l && tree2[root].r <= r)
    {
        tree2[root].tag += add;
        tree2[root].val += (tree2[root].r - tree2[root].l + 1) * add;
        return;
    }
    if(tree2[root].tag) down2(root);
    int mid = (tree2[root].l + tree2[root].r) >> 1;
    if(l <= mid) update2(root << 1, l, r, add);
    if(r > mid) update2(root << 1 | 1, l, r, add);
    tree2[root].val = tree2[root << 1].val + tree2[root << 1 | 1].val;
}

int ask1(int root, int l, int r)
{
    if(tree1[root].l >= l && tree1[root].r <= r) return tree1[root].val;
    if(tree1[root].tag) down1(root);
    int mid = (tree1[root].l + tree1[root].r) >> 1, ans = 0;
    if(l <= mid) ans += ask1(root << 1, l, r);
    if(r > mid) ans += ask1(root << 1 | 1, l, r);
    return ans;
}

int ask2(int root, int l, int r)
{
    if(tree2[root].l >= l && tree2[root].r <= r) return tree2[root].val;
    if(tree2[root].tag) down2(root);
    int mid = (tree2[root].l + tree2[root].r) >> 1, ans = 0;
    if(l <= mid) ans += ask2(root << 1, l, r);
    if(r > mid) ans += ask2(root << 1 | 1, l, r);
    return ans;
}

int main()
{
    cin >> n >> m;
    build(1, 1, n);
    for(int i = 1; i <= m; i++)
    {
        int op = read(), l = read(), r = read();
        if(op == 1) update1(1, l, l, 1), update2(1, r, r, 1);
        else printf("%d\n", ask1(1, 1, r) - ask2(1, 1, l - 1));
    }
    return 0;
}

转载于:https://www.cnblogs.com/BigYellowDog/p/11156424.html