• CF526F Pudding Monsters


    只会 n做法

    n2 做法就是简化题意后打个暴力...

    首先化简题意,变成了要求一个序列中,

    最大值 - 最小值 = 区间长度 - 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
    ", ans);
        return 0;
    }
  • 相关阅读:
    fpga的特殊引脚 说明
    STM32的命名规范和选型
    阻容降压原理和算法
    判断三极管工作在哪个区
    modelsim仿真中 do文件的写法技巧
    场和帧的 关系(转)
    基于DSP/ARM图像采集原理和器件选型(转)
    非专业程序员谈程序员修炼之路
    产生指定范围不重复的随机数,产生指定数组不重复的随机数
    解决git下载很慢的问题
  • 原文地址:https://www.cnblogs.com/xcysblog/p/9886211.html
Copyright © 2020-2023  润新知