Mayor's posters (線段樹+離散化)

Mayor's posters

 

Description

The citizens of Bytetown, AB, could not stand that the candidates in the mayoral election campaign have been placing their electoral posters at all places at their whim. The city council has finally decided to build an electoral wall for placing the posters and introduce the following rules:

• Every candidate can place exactly one poster on the wall.
• All posters are of the same height equal to the height of the wall; the width of a poster can be any integer number of bytes (byte is the unit of length in Bytetown).
• The wall is divided into segments and the width of each segment is one byte.
• Each poster must completely cover a contiguous number of wall segments.

They have built a wall 10000000 bytes long (such that there is enough place for all candidates). When the electoral campaign was restarted, the candidates were placing their posters on the wall and their posters differed widely in width. Moreover, the candidates started placing their posters on wall segments already occupied by other posters. Everyone in Bytetown was curious whose posters will be visible (entirely or in part) on the last day before elections.
Your task is to find the number of visible posters when all the posters are placed given the information about posters' size, their place and order of placement on the electoral wall.

Input

The first line of input contains a number c giving the number of cases that follow. The first line of data for a single case contains number 1 <= n <= 10000. The subsequent n lines describe the posters in the order in which they were placed. The i-th line among the n lines contains two integer numbers l_i and ri which are the number of the wall segment occupied by the left end and the right end of the i-th poster, respectively. We know that for each 1 <= i <= n, 1 <= l_i <= ri <= 10000000. After the i-th poster is placed, it entirely covers all wall segments numbered l_i, l_i+1 ,... , ri.

Output

For each input data set print the number of visible posters after all the posters are placed.

The picture below illustrates the case of the sample input.

Sample Input

1
5
1 4
2 6
8 10
3 4
7 10

Sample Output

4

這是一道很經典的線段樹離散化問題,題目中給出的區間[li,ri]的數據都很大,直接用線段樹作的話至少須要10000000*4的空間,所以,咱們首先要對數據進行離散化處理
首先,咱們要弄清楚離散化的概念,咱們根據題目樣例進行分析,能夠看到[1,4],[2,6],[8,10],[3,4],[7,10]這五個區間,咱們將這10個數都拿出來排個序,建立序列a
1 2 3 4 4 6 7 8 10 10
接下來咱們對序列a去下重
1 2 3 4 6 7 8 10
而後咱們用他們的相對大小(例如:6在這個序列中是第5大,10在這個序列中是第8大)創建另外一個序列b
1 2 3 4 5 6 7 8
最後咱們用每一個數對應的相對大小來替換原來的區間就變成了這樣
[1,4],[2,5],[7,8],[3,4],[6,8]
咱們用這個區間來計算一下最後能觀察到的海報數的話會發現,結果仍然是4

我我的對離散化的理解就是用數字的相對大小來替換他的實際大小從而達到減少其值,卻不破壞它的位置關係的目的
這道題咱們利用這樣的方法就能將li,ri這麼大的數縮小到最大隻有20000(由於最多有20000個點)
理解題意後咱們直接看代碼,至於線段樹部分就是普通的區間修改而已

#pragma GCC optimize("Ofast")

#include <iostream>
#include <algorithm>
#include <set>

using namespace std;

#define endl '\n'
#define ll long long

struct node
{
    int l, r, flag;
} tree[800005];

int base[20005], ls[20005];
set<int> s;

void tree_build(int i, int l, int r)
{
    tree[i].l = l;
    tree[i].r = r;
    tree[i].flag = 0;
    if (l == r)
    {
        return;
    }
    int mid = (l + r) >> 1;
    tree_build(i << 1, l, mid);
    tree_build(i << 1 | 1, mid + 1, r);
}

void push_down(int i)
{
    if (tree[i].flag)
    {
        tree[i << 1].flag = tree[i].flag;
        tree[i << 1 | 1].flag = tree[i].flag;
        tree[i].flag = 0;
    }
}

void update(int i, int l, int r, int num)
{
    if (tree[i].l >= l && tree[i].r <= r)
    {
        tree[i].flag = num;
        return;
    }
    if (tree[i].r < l || tree[i].l > r)
    {
        return;
    }
    push_down(i);
    if (tree[i << 1].r >= l)
    {
        update(i << 1, l, r, num);
    }
    if (tree[i << 1 | 1].l <= r)
    {
        update(i << 1 | 1, l, r, num);
    }
}

void search(int i, int l, int r)
{
    if (tree[i].flag)
    {
        s.insert(tree[i].flag);//利用set自動去重的性質來記錄海報數量
        return;
    }
    if (l == r)
    {
        return;
    }
    int mid = (l + r) >> 1;
    search(i << 1, l, mid);
    search(i << 1 | 1, mid + 1, r);
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        int n, x, y, pos = 1;
        cin >> n;
        s.clear();
        tree_build(1, 1, 200005);
        for (int i = 1; i <= n; ++i)
        {
            //這地方咱們開兩個數組，base用與計算每一個數的相對位置，ls是離散化後的數組
            cin >> x >> y;
            base[pos] = x;
            ls[pos++] = x;
            base[pos] = y;
            ls[pos++] = y;
        }
        //不管是sort仍是unique仍是lower_bound區間設定都是左閉右開的形式，品，你細細的品
        sort(base + 1, base + pos);
        int num = unique(base + 1, base + pos) - base;//對base排序並去重，必須排序後才能用unique
        for (int i = 1; i < pos; ++i)
        {
            ls[i] = lower_bound(base + 1, base + num, ls[i]) - base;
        }
        for (int i = 2; i < pos; i += 2)
        {
            update(1, ls[i - 1], ls[i], i);
        }
        search(1, 1, 200005);
        cout << s.size() << endl;
    }
    return 0;
}

 

你覺得這就完事了?其實這樣離散化在這道題中會有一些bug,咱們看這組數據[1,10],[1,3],[6,10],很明顯答案是3
可是離散化以後爲[1,4],[1,2],[3,4],答案變成了2
爲解決這種問題,咱們能夠在更新線段樹的時候將區間從[l,r]變成[l,r-1],就將區間轉化成了[1,3],[1,1],[3,3]這樣的樹
可是當咱們遇到這樣的數據[1,3],[1,1],[2,2],[3,3],就會致使區間更新時出錯,咱們能夠將初始數據的r都加上1,就排除了li和ri相等的狀況,若是沒有這種狀況,離散化後的區間也都是同樣的
其實這道題數據很弱,無論這樣的狀況也能過(逃

#pragma GCC optimize("Ofast")

#include <iostream>
#include <algorithm>
#include <set>

using namespace std;

#define endl '\n'
#define ll long long

struct node
{
    int l, r, flag;
} tree[100005];

int base[20005], ls[20005];
set<int> s;

void tree_build(int i, int l, int r)
{
    tree[i].l = l;
    tree[i].r = r;
    tree[i].flag = 0;
    if (l == r)
    {
        return;
    }
    int mid = (l + r) >> 1;
    tree_build(i << 1, l, mid);
    tree_build(i << 1 | 1, mid + 1, r);
}

void push_down(int i)
{
    if (tree[i].flag)
    {
        tree[i << 1].flag = tree[i].flag;
        tree[i << 1 | 1].flag = tree[i].flag;
        tree[i].flag = 0;
    }
}

void update(int i, int l, int r, int num)
{
    if (tree[i].l >= l && tree[i].r <= r)
    {
        tree[i].flag = num;
        return;
    }
    if (tree[i].r < l || tree[i].l > r)
    {
        return;
    }
    push_down(i);
    if (tree[i << 1].r >= l)
    {
        update(i << 1, l, r, num);
    }
    if (tree[i << 1 | 1].l <= r)
    {
        update(i << 1 | 1, l, r, num);
    }
}

void search(int i, int l, int r)
{
    //cout << tree[i].flag << " " << tree[i].l << " " << tree[i].r << endl;
    if (tree[i].flag)
    {
        //cout << tree[i].flag << " " << tree[i].l << " " << tree[i].r << endl;
        s.insert(tree[i].flag);
        return;
    }
    if (l == r)
    {
        return;
    }
    int mid = (l + r) >> 1;
    search(i << 1, l, mid);
    search(i << 1 | 1, mid + 1, r);
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin >> t;
    while (t--)
    {
        int n, x, y, pos = 1;
        cin >> n;
        s.clear();
        tree_build(1, 1, 20005);
        for (int i = 1; i <= n; ++i)
        {
            cin >> x >> y;
            base[pos] = x;
            ls[pos++] = x;
            base[pos] = y + 1;
            ls[pos++] = y + 1;
        }
        sort(base + 1, base + pos);
        int num = unique(base + 1, base + pos) - base;
        for (int i = 1; i < pos; ++i)
        {
            ls[i] = lower_bound(base + 1, base + num, ls[i]) - base;
        }
        for (int i = 2; i < pos; i += 2)
        {
            update(1, ls[i - 1], ls[i] - 1, i);
        }
        search(1, 1, 20005);
        cout << s.size() << endl;
    }
    return 0;
}