如何从向量中删除除特定范围内最大的元素之外的所有元素？

Question

假设我有以下向量：

向量是成对的向量，我们根据第一个元素进行比较。

[(1,0),(0,1),(3,2),(6,3),(2,4),(4,5),(7,6),(5,7)]

我想删除特定范围内的所有元素，除了最大的。

例如，如果范围是 $l = 2$ 和 $r = 5$，那么输出：

[(1,0),(0,1),(6,3),(7,6),(5,7)]

现在如果我们对 $l = 1$, $r = 4$ 的输出数组再次执行此操作，则输出：

[(1,0),(7,6)]

我找到了this，我认为它在这里很有用，但我不知道如何让它对成对起作用。

这是我的尝试：

int main(int argc, char const *argv[]) {
    int N;
    cin >> N;
    vector< pair<int,int> > vector_of_pairs(N);

    for (int i = 0; i < N; i++) {
        int input;
        cin >> input;
        vector_of_pairs[i] = make_pair(input, i);
    }

    int l, r;
    cin >> l >> r;

    int max_in_range = vector_of_pairs[l].first;

    for (int i = l+1; i <= r; i++) {
        if (vector_of_pairs[i].first > max_in_range) {
            max_in_range = vector_of_pairs[i].first;
        }
    }

    for (int i = l; i <= r; i++) {
        if (vector_of_pairs[i].first != max_in_range) {
            vector_of_pairs.erase(vector_of_pairs.begin() + i);
        }
    }

    printf("[");
    for(int i = 0; i < vector_of_pairs.size(); i++) {
        printf("(%d,%d)", vector_of_pairs[i].first, vector_of_pairs[i].second);
    }
    printf("]\n");
}

对于以下输入：

8              
1 0 5 6 2 3 7 4 
1 3

这是输出：

[(1,0)(5,2)(6,3)(3,5)(7,6)(4,7)]

但应该是的

[(1,0)(6,3)(3,5)(7,6)(4,7)]

另外，对于某些输入，我会遇到段错误，那么我该如何防范呢？

Answer 1

Erase remove idiom 在救援中：

auto begin = v.begin() + l;
auto end = v.begin() + r + 1;
auto max_value = *std::max_element(begin, end);
v.erase(std::remove_if(begin, end,
                       [&](const auto& p) {return p.first != max_value.first; }),
        end);

Demo

Answer 2

可能你想要这个

#include <iostream>
#include <vector>
using namespace std;


int main(int argc, char const *argv[]) {
    int N;
    cin >> N;
    vector< pair<int,int> > vector_of_pairs(N);

    for (int i = 0; i < N; i++) {
        int input;
        cin >> input;
        vector_of_pairs[i] = make_pair(input, i);
    }

    int l, r;
    cin >> l >> r;

    int max_in_range = vector_of_pairs[l].first;

    for (int i = l+1; i <= r; i++) {
        if (vector_of_pairs[i].first > max_in_range) {
            max_in_range = vector_of_pairs[i].first;
        }
    }
    int p=l;
    for (int i = l; i <= r;i++ ) {
        if (vector_of_pairs[p].first != max_in_range) {
            vector_of_pairs.erase(vector_of_pairs.begin()+p);
        }
        else p++; 
    }

    printf("[");
    for(int i = 0; i < vector_of_pairs.size(); i++) {
        printf("(%d,%d)", vector_of_pairs[i].first, vector_of_pairs[i].second);
    }
    printf("]\n");
}

得到正确的输出：

[(1,0)(6,3)(2,4)(3,5)(7,6)(4,7)]

解释：当你删除向量中的一个项目时，在被删除元素之后出现的项目的索引减少了 1。因此在从 l 到 r 的第 i 个循环中，你不应该删除 vec.begin ()+i 元素，改为删除 vec.begin()+l 项直到找到最大元素，找到最大元素后删除 vec.begin()+l+1 元素。

希望对你有帮助。

Answer 3

如果您不需要稳定的算法，您可以简单地对向量进行排序，在 begin - end 中获取 l 的迭代器，在 l - end 中获取 r 的迭代器，然后删除除最后一个元素之外的所有元素都找到了迭代器。

#include <algorithm>
template<class V, class T>
void remove_range_but_max(V& vop, T const& l, T const& r)
{
    std::sort(vop.begin(), vop.end());
    auto lo = std::lower_bound(vop.begin(), vop.end(), l);
    auto hi = std::lower_bound(lo, vop.end(), r);
    if(hi != lo) --hi;
    vop.erase(lo, hi);
}

可以这样使用：

std::vector< std::pair< int , int > > input { 
    std::make_pair( 1 , 0 ) , std::make_pair( 0 , 1 ) , 
    std::make_pair( 3 , 2 ) , std::make_pair( 6 , 3 ) , 
    std::make_pair( 2 , 4 ) , std::make_pair( 4 , 5 ) , 
    std::make_pair( 7 , 6 ) , std::make_pair( 5 , 7 ) };
/* remove all pairs in range [(2,0), (6,0)) */
remove_range_but_max(input, std::make_pair(2,0), std::make_pair(6,0));
for(auto&& p : input) std::cout << p.first << ", " << p.second << "\n";

打印：

0, 1
1, 0
5, 7
6, 3
7, 6

Answer 4

快速而低俗的方式：

std::sort(vector_of_pairs.begin(), vector_of_pairs.end());
vector_of_pairs.resize(1);

只需确保为 sort 提供适当的函数，以使最大的元素被推送到列表的第一个。

让我为你拼写出来：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool i_said_to_do_this(const pair<int, int> &lhs, const pair<int, int> &rhs) {
  return lhs.first > rhs.first;
}

int main(int argc, char const *argv[]) {

    int pairs[][2] = {{1,0},{0,1},{3,2},{6,3},{2,4},{4,5},{7,6},{5,7}}; 
    vector< pair<int,int> > vector_of_pairs(8);

    for (int i{0}; i < 8; i++) {
      vector_of_pairs[i] = make_pair(pairs[i][0], pairs[i][1]);
    }

    std::sort(vector_of_pairs.begin(), vector_of_pairs.end(), i_said_to_do_this);
    vector_of_pairs.erase(vector_of_pairs.begin() + 1, vector_of_pairs.end());

    cout << "(" << vector_of_pairs[0].first << ", " << vector_of_pairs[0].second << ")" << endl;
}