CF526F Pudding Monsters

只會 n² 做法

n² 做法就是簡化題意后打個暴力...

首先化簡題意，變成了要求一個序列中，

最大值 - 最小值 = 區間長度 - 1 的區間個數

數據范圍很大，考慮分治，每層分治考慮過中點的答案

下面我就不會了= =

分以下幾種情況：

1.max 在中點左邊，min 也在中點左邊

2.max 在中點右邊，min 也在中點右邊

3.max 在中點左邊，min 在中點右邊

4.max 在中點右邊，min 在中點左邊

方便分析我們把它簡化成兩種情況：min 和 max 在不在同一側

在同一側的情況

求出每個點到中點區間上的最小值和最大值

枚舉答案區間的一個端點，
另一個端點一定是在另一側距離當前點距離為 max_i - min_i 的位置

判斷一下那個端點 max 是否更大，min 是否更小即可

不在同一側的情況

考慮固定一個端點，只要能均攤 O(1) 就行

以拿這個端點 p 作為最大值為例(其實都是可以的)
確定了最大值在這一側，那么最小值在另一側，
則另一端點一定是一些滿足 min_now < min_p 且 max_now < max_p 的點
而前綴 min / max 顯然是有單調性的，所以這些點一定是一個區間
直接上是 n^2 的，但如果從中點往一側做的話，合法的區間的移動是有單調性的

這樣做一遍也是 O(n) 的了

感覺此題分治里的分類討論方式非常獨特啊

---

 代碼：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <cstdio>
#include <locale>
using namespace std;

typedef long long ll;
const int MAX_N = 300005;

struct POS {
    int lin, clm;
    explicit POS(int X = 0, int Y = 0) {lin = X; clm = Y;}
    bool operator < (const POS& b) const {
        return lin < b.lin;
    }
};
int n;
POS pos[MAX_N];
int cur_max[MAX_N], cur_min[MAX_N], cnt[MAX_N << 1];
ll ans;

inline int rd() {
    register int x = 0, c = getchar();
    while (!isdigit(c)) c = getchar();
    while (isdigit(c)) {
        x = x * 10 + (c ^ 48);
        c = getchar();
    }
    return x;
}
inline void init_min_max(int l, int mid, int r) {
    cur_max[mid] = 0; cur_min[mid] = 0x3f3f3f3f;
    for (int i = mid + 1; i <= r; ++i) {
        cur_max[i] = max(cur_max[i - 1], pos[i].clm);
        cur_min[i] = min(cur_min[i - 1], pos[i].clm);
    }
    cur_max[mid] = cur_min[mid] = pos[mid].clm;
    for (int i = mid - 1; i >= l; --i) {
        cur_max[i] = max(cur_max[i + 1], pos[i].clm);
        cur_min[i] = min(cur_min[i + 1], pos[i].clm);
    }
}
inline void calc_same(int l, int mid, int r) {
    register int dst = 0;
    for (int i = l; i <= mid; ++i) {
        dst = cur_max[i] - cur_min[i] + i;
        ans += (mid < dst && dst <= r && cur_max[dst] < cur_max[i] && cur_min[dst] > cur_min[i]);
    }
    for (int i = mid + 1; i <= r; ++i) {
        dst = i - cur_max[i] + cur_min[i];
        ans += (l <= dst && dst <= mid && cur_max[dst] < cur_max[i] && cur_min[dst] > cur_min[i]);
    }
}
inline void calc_diff(int l, int mid, int r) {
    register int max_ptr = mid + 1, min_ptr = mid + 1;
    for (int i = mid; i >= l; --i) {
        while (max_ptr <= r && cur_max[max_ptr] <= cur_max[i]) {
            ++cnt[cur_min[max_ptr] + max_ptr];
            ++max_ptr;
        }
        while (min_ptr < max_ptr && cur_min[min_ptr] >= cur_min[i]) {
            --cnt[cur_min[min_ptr] + min_ptr];
            ++min_ptr;
        }
        ans += cnt[cur_max[i] + i];
    }
    while (min_ptr < max_ptr) {
        --cnt[cur_min[min_ptr] + min_ptr];
        ++min_ptr;
    }
    max_ptr = mid; min_ptr = mid;
    for (int i = mid + 1; i <= r; ++i) {
        while (max_ptr >= l && cur_max[max_ptr] <= cur_max[i]) {
            ++cnt[cur_min[max_ptr] - max_ptr + n];
            --max_ptr;
        }
        while (min_ptr > max_ptr && cur_min[min_ptr] >= cur_min[i]) {
            --cnt[cur_min[min_ptr] - min_ptr + n];
            --min_ptr;
        }
        ans += cnt[cur_max[i] - i + n];
    }
    while (min_ptr > max_ptr) {
        --cnt[cur_min[min_ptr] - min_ptr + n];
        --min_ptr;
    }
}
inline void dvd(int l, int r) {
    int mid = ((l + r) >> 1);
    if (l == r) {
        ++ans;
        return;
    }
    dvd(l, mid); dvd(mid + 1, r);
    init_min_max(l, mid, r);
    calc_same(l, mid, r);
    calc_diff(l, mid, r);
}

int main() {
    n = rd();
    for (int i = 1; i <= n; ++i) {
        pos[i].lin = rd();
        pos[i].clm = rd();
    }
    sort(pos + 1, pos + n + 1);
    dvd(1, n);
    printf("%lld\n", ans);
    return 0;
}