序列计数 CS精英挑战营习题

序列计数
描述
给定一个n个整数的序列以及一个非负整数d，请你输出这个序列中有多少个连续子序列（长度大于1），满足该子序列的最大值最小值之差不大于d。

连续子序列：序列1 2 3中长度大于1的连续子序列有：

1 2
2 3
1 2 3
输入
第一行包含两个整数n,d。

接下来一行包含n个整数。

输出
输出一个整数，表示满足条件的连续子序列个数。

样例1输入
8 5
5 5 4 8 -10 10 0 1
样例1输出
7
样例1解释
满足条件的连续子序列有：

5 5
5 5 4
5 5 4 8
5 4
5 4 8
4 8
0 1
样例2
请查看下发文件内的sample2_input.txt和sample2_output.txt。

限制
对于60%的数据，n ≤ 5000；

对于100%的数据，n ≤ 300000。

保证所有整数的绝对值不超过10 ^ 9 ，d不超过 2×10 ^ 9。

时间：10 sec

空间：512 MB

注意：
n=5000 对应复杂度n^2
n= 300000 对应复杂度nlogn

解法一枚举

枚举左端点&枚举右端点。

plus

如果我们递增枚举左端点，那么可以发现右端点是单调递增的。
也就从堆中取出最大值和最小值，找到不能拓展的地方为止。

解法二分治

始终注意：右端点单调不下降

[考虑分治。]

[令函数solve(l, r)表示统计[l, r]中合法的连续子序列个数，mid为(l+r)/2（下取整），那么]

[solve(l, r) = 0, 当l = r]

[solve(l, r) = solve(l, mid) + solve(mid + 1, r) + cal(l, r, mid)，当l≠r]

[其中cal(l, r, mid)表示在左端点在区间[l, mid]中、右端点在区间[mid + 1, r]中的符合要求的连续子序列数目]

[那么答案就是solve(1, n)。]

[至于cal(l, r, mid)怎么算，大家可以仔细思考思考。（右端点是有单调性的）]
对于枚举左端点，右端点有posi-mid个序列（如何判断加1还是减1）对于加减一问题最好的方法是枚举临界值。
posi如何寻找，可以用bbst或者堆，但是该数据结构本身就存在复杂度。
需要一个线性的计算方式，选出最大最小值以及他们的差值。
统计有半段前缀最小值以及前缀最大值。
再从mid递减 枚举计算当前的最小值最大值

[注意答案要用long long]

[（另外这题也可以用线性的方法做哦~有兴趣去搜一搜单调栈）]

#include <vector>
#include <stdio.h>
#include <algorithm> 
using namespace std;

// ================= 代码实现开始 =================
const int N = 300005;

//n 数组长度 d为第二个输入量b
//max_value 用于存储solve函数中的前缀最大值
//min_value 用于存储solve函数中的前缀最小值
//a 数组a,长度为n

int n, d, max_value[N], min_value[N];
vector<int> a;

//分治计算区间[l,r]中，有多少个连续子序列满足最大值最小值之差不大于d
//l：区间左边界
//r：区间右边界
//返回值：满足条件的连续子序列的个数
long long solve(int l, int r){
    if(l==r)
        return 0;
    
    int mid = (l+r)>>1; //中点
    long long ans =   solve(l,mid) + solve(mid+1,r);//分治求出左右两半的值。
    
    //我们计算区间[mid+1，r]的前缀最小值和前缀最大值。
    //也就是说min_value[i] = min(a[mid+1...i])i,max_value同理
    for(int i = mid + 1; i <= r; ++i){
        min_value[i] = (i==mid+1) ? a[i]:min(min_value[i-1],a[i]);
        max_value[i] = (i==mid+1) ? a[i]:max(max_value[i-1],a[i]);
    }
    
    //我们倒序枚举子序列的左端点i，i的取值范围  在[i，mid]
    //pos表示若连续子序列的左端点是i，那么子序列的右端点最远能拓展到pos位置，当然pos取值范围在[mid+1,r],一开始初始化为r
    //mn是后缀最小值，mx是后缀最大值，也就是说mn=min([i...mid]),mx同理
    //那么在以i为左端点的连续子序列(右端点在[mid+1,r]内)个数应该有pos-mid个
    int mn = 0, mx = 0, pos = r;
 //   printf("mid= %d , pos= %d \n",mid ,pos);
    for(int i = mid; i >= l && pos > mid; --i){
        mn = (i==mid) ? a[i] : min(a[i],mn);
        mx = (i==mid) ? a[i] : max(a[i],mx);
 //       printf("i= %d , mn= %d , mx= %d \n",i,mn,mx);
        for(;pos>mid && max(mx,max_value[pos])-min(mn,min_value[pos])>d;--pos);
        ans+= pos-mid;
     }
    return ans;
}

// 求出有多少个a数组中的连续子序列（长度大于1），满足该子序列的最大值最小值之差不大于d
// n：a数组的长度
// d：所给d
// a：数组a，长度为n
// 返回值：满足条件的连续子序列的个数
long long getAnswer(int n, int d, vector<int> a) {
    //复制到全局变量
    ::n = n;
    ::d = d;
    ::a = a;
    return solve(0, n-1);
}

// ================= 代码实现结束 =================


int main() {
    int n, d;
    scanf("%d%d", &n, &d);
    vector<int> a;
    a.resize(n);
    for (int i = 0; i < n; ++i)
        scanf("%d", &a[i]);
    printf("%lld\n", getAnswer(n, d, a));
    return 0;
}