#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <deque>

// 中值滤波函数
std::vector<int> medfilt(const std::vector<int>& input, int kernel_size) {
    if (input.empty() || kernel_size % 2 == 0) return {};
    
    int pad = kernel_size / 2;
    std::vector<int> output(input.size());
    std::deque<int> window;
    
    // 初始化窗口
    for (int i = 0; i < kernel_size; ++i) {
        window.push_back(input[std::max(0, i - pad)]);
    }
    std::sort(window.begin(), window.end());
    
    for (int i = 0; i < input.size(); ++i) {
        // 移除旧值
        if (i - pad - 1 >= 0) {
            auto it = std::lower_bound(window.begin(), window.end(), input[i - pad - 1]);
            window.erase(it);
        }
        
        // 添加新值
        if (i + pad < input.size()) {
            auto it = std::upper_bound(window.begin(), window.end(), input[i + pad]);
            window.insert(it, input[i + pad]);
        } else if (!window.empty()) {
            window.push_back(window.back());
        }
        
        // 获取中值
        output[i] = window[window.size() / 2];
    }
    
    return output;
}

// 计算差分
std::vector<int> calculate_diff(const std::vector<int>& input) {
    std::vector<int> diff;
    for (size_t i = 1; i < input.size(); ++i) {
        diff.push_back(input[i] - input[i-1]);
    }
    return diff;
}

int main() {
    // 假设输入数据
    std::vector<int> list_posi = { /* 你的数据 */ };
    int _step = 1; // 根据实际情况调整步长
    
    // 1. 中值滤波
    std::vector<int> filtered = medfilt(list_posi, 5);
    
    // 2. 计算差分
    std::vector<int> filtered_diff = calculate_diff(filtered);
    
    // 3. 寻找有效区间
    std::vector<std::pair<int, int>> list_range;
    size_t i = 0;
    while (i < filtered_diff.size() - 10) {
        if (filtered_diff[i] < 5) {
            // 检查后续10个点是否有小于0的值
            bool has_negative = false;
            for (size_t j = i + 1; j <= i + 10; ++j) {
                if (j < filtered_diff.size() && filtered_diff[j] < 0) {
                    has_negative = true;
                    break;
                }
            }
            
            if (has_negative) {
                int index_start = i;
                i += 10; // 跳过已检查区域
                
                // 寻找结束点
                bool found_end = false;
                while (i < filtered_diff.size() - 10) {
                    // 检查后续10个点是否全部大于0
                    bool all_positive = true;
                    for (size_t j = i + 1; j <= i + 10; ++j) {
                        if (j >= filtered_diff.size() || filtered_diff[j] <= 0) {
                            all_positive = false;
                            break;
                        }
                    }
                    
                    if (all_positive) {
                        int index_end = i;
                        list_range.push_back({index_start, index_end});
                        found_end = true;
                        break;
                    }
                    ++i;
                }
                
                if (!found_end) {
                    // 未找到结束点，跳出循环
                    break;
                }
            }
        }
        ++i;
    }
    
    // 4. 过滤点集
    std::vector<std::vector<int>> points; // 假设原始点集
    std::vector<std::vector<int>> points_filter;
    
    for (auto& point : points) {
        int x_cut = 0;
        bool flag = true;
        
        for (const auto& range : list_range) {
            int x_min = range.first * _step;
            int x_max = range.second * _step;
            
            if (point[0] >= x_max) {
                x_cut += (x_max - x_min);
            } else if (point[0] >= x_min && point[0] <= x_max) {
                flag = false;
                break;
            }
        }
        
        if (flag) {
            point[0] -= x_cut;
            points_filter.push_back(point);
        }
    }
    
    // 输出结果 (示例)
    std::cout << "Filtered points count: " << points_filter.size() << std::endl;
    
    return 0;
}