连号区间数

题目：

小明这些天一直在思考这样一个奇怪而有趣的问题：

在 1 ~ 𝑁N 的某个全排列中有多少个连号区间呢？

这里所说的连号区间的定义是：

如果区间 [𝐿,𝑅][L,R] 里的所有元素（即此排列的第 𝐿L 个到第 𝑅R 个元素）递增排序后能得到一个长度为 𝑅−𝐿+1R−L+1 的"连续"数列，则称这个区间连号区间。

当 𝑁N 很小的时候，小明可以很快地算出答案，但是当 𝑁N 变大的时候，问题就不是那么简单了，现在小明需要你的帮助。

输入描述

第一行是一个正整数 𝑁(1≤𝑁≤50×104)N(1≤N≤50×104), 表示全排列的规模。

第二行是 𝑁N 个不同的数字 𝑃𝑖 (1≤𝑃𝑖≤𝑁)Pi​ (1≤Pi​≤N)，表示这 𝑁N 个数字的某一全排列。

输出描述

输出一个整数，表示不同连号区间的数目。

输入输出样例

示例

输入

4
3 2 4 1

输出

7

解析：

1、连续区间判断

1）、相差为1

2）、max-min=k-1

1. 找到区间中的最大值 max 和最小值 min。
2. 如果区间内有 ( k ) 个数字，那么连续数列的最大值和最小值之间的差应该是 ( k - 1 )。
3. 同时，你还要检查区间内是否有重复的数字。如果有重复的数字，说明它不是连续的。

具体步骤：

• 计算区间内的最大值 max 和最小值 min。
• 如果 ( \text{max} - \text{min} = \text{区间大小} - 1 ) 且没有重复的数字，则说明这个区间是连续的。

代码：

代码1：80%通过，运行超时--求连续序列,max-min=k-1

#include <iostream>
#include <deque>
#include <unordered_set>
using namespace std;

const int N = 5e5 + 10;
int p[N];

bool check(int n, int m) {
    int length = m - n + 1;
    int min_val = p[n], max_val = p[n];
    unordered_set<int> unique_elements;

    // 计算区间的最小值、最大值，并检查是否有重复元素
    for (int i = n; i <= m; i++) {
        if (unique_elements.count(p[i])) {
            return false;  // 如果有重复元素，直接返回 false
        }
        unique_elements.insert(p[i]);
        min_val = min(min_val, p[i]);
        max_val = max(max_val, p[i]);
    }

    // 判断最大值和最小值之差是否等于区间长度 - 1
    return (max_val - min_val == length - 1);
}

int main() {
    int n, c = 0;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> p[i];
    }

    // 检查所有区间
    for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            if (check(i, j)) {
                c++;
            }
        }
    }

    cout << c << endl;
    return 0;
}

代码2：80%，暴力运行超时---求连续序列，p[i]!=p[i]+1,flage=0;

#include <iostream>
 #include <cstring>
 #include <algorithm>
using namespace std;
 const int N = 1e4+10;

 int a[N];
 int backup[N];

int main()
 {
    ios::sync_with_stdio(0) , cin.tie(0);
    int n ;
    int res = 0;
     cin>>n;
     for (int i = 0; i < n; i ++ ) cin>>a[i];
     memcpy(backup, a, sizeof a);
    
     for (int i = 0; i < n; i ++ ){
         for (int j = i; j < n; j ++ ){
             memcpy(a, backup, sizeof backup);
            sort(a+i , a+j+1);
             bool flag = true;
            
             for (int k = i+1; k <= j; k ++ ){
                 if(a[k]!=a[k-1]+1){
                    flag = false;
                     break;
                 }
             }
             if(flag) res++;
         }
    }
     cout<<res;
     return 0;
    
    
 }

代码1，2都是用的三重循环，接下来进行优化

代码3：二重循环100%通过--max-min=k-1

#include <bits/stdc++.h>
using namespace std;

const int N = 5e5 + 10, INF = 1e8;
int n, res;
int a[N];

int main()
{
  scanf("%d", &n);
  for (int i = 0; i < n; i++) scanf("%d", &a[i]);

  for (int i = 0; i < n; i++)
  {
    int maxv = -INF, minv = INF;
    for (int j = i; j < n; j++)
    {
      maxv = max(maxv, a[j]);
      minv = min(minv, a[j]);
      if (maxv - minv == j - i) res++;
    }
  }

  printf("%d\n", res);

  return 0;
}

直接每一个i-j，j++的区间判断最值就行，因为始终是这个序列，只是往后面添加了元素了，避免了重复查询最值

代码4：双端队列--求最值

和代码3类似，只不过用到了队列的思想

#include <iostream>
#include <deque>
#include <unordered_set>
using namespace std;

const int N = 5e5 + 10;
int p[N];

int main() {
    int n, c = 0;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> p[i];
    }

    // 双端队列维护区间内的最大值和最小值
    deque<int> max_deque, min_deque;
    unordered_set<int> current_window_elements;
    
    for (int i = 1; i <= n; i++) {
        max_deque.clear();
        min_deque.clear();
        current_window_elements.clear();
        
        // 从 i 开始扩展窗口
        for (int j = i; j <= n; j++) {
            // 如果新元素已经在窗口内，跳出
            if (current_window_elements.count(p[j])) {
                break;
            }
            
            // 更新哈希集合
            current_window_elements.insert(p[j]);
            
            // 更新最大值队列
            while (!max_deque.empty() && p[max_deque.back()] <= p[j]) {
                max_deque.pop_back();
            }
            max_deque.push_back(j);
            
            // 更新最小值队列
            while (!min_deque.empty() && p[min_deque.back()] >= p[j]) {
                min_deque.pop_back();
            }
            min_deque.push_back(j);

            // 计算当前窗口的最小值和最大值
            int min_val = p[min_deque.front()];
            int max_val = p[max_deque.front()];
            
            // 检查区间的最大值 - 最小值是否等于区间长度 - 1
            if (max_val - min_val == j - i) {
                c++;
            }
        }
    }

    cout << c << endl;
    return 0;
}