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;
}