从一维向量vector<int>开始复制到二维向量对vector<pair<int,int>>matrix的第一个元素

Question

我有多个 3 个一维向量 (vector<int> starts, vector<int> ends, vector<int> points)。每个都有特定数量的元素。

我想以这样的顺序创建一个二维向量vector<pair<int,int>>matrix：

1. 从matrix的开头到start的大小第一个元素matrix是vector<int> starts的元素，第二个元素是“-1”
2. 现在将vector<int> ends 的元素附加到matrix，这样matrix 的第一个 元素是vector<int> ends 的元素，第二个 元素是“-2 "

3. 现在将vector<int> points 的元素附加到matrix，这样matrix 的first 元素是vector<int> points 的元素，second 元素是点的索引.

   视觉表现：-

   输入：

   开始：{1, 2, 3} 结束：{4, 5, 6} 积分：(7, 8, 9}

   输出：

   矩阵：{ {1, -1}, {2, -1}, {3, -1}, {4, -2}, {5, -2}, {6, -2}, {7, 0}, {8, 1}, {9, 2} }

目前我正在使用带有 for-loop 函数的 push_back，它工作得非常好，但是当输入大小很大时，代码非常慢。

我使用的代码如下：

vector<pair<int,int>> fast_count_segments(
    vector<int> starts, 
    vector<int> ends, 
    vector<int> points) 
{
   int i = 0;
   vector<pair<int,int>>matrix;

   for(i; i<starts.size(); i++) {
       matrix.push_back(make_pair(starts[i],-1));
   }
   for(i; i<starts.size()+ends.size(); i++) {
       matrix.push_back(make_pair(ends[i-starts.size()],-2));
   }
   for(i; i<starts.size()+ends.size()+points.size(); i++) {
        matrix.push_back(make_pair(
            points[i-starts.size()-ends.size()],
            i-(starts.size()+ends.size())
        ));
   }
   return matrix;
}

您能否帮助您了解如何在不遍历每个元素的情况下快速填充 2D 向量。我正在使用 C++11。提前致谢！！

Answer 1

初步关注：正如@datenwolf 和其他人所指出的 - 您生成的数据结构不是二维矩阵（除非您指的是稀疏表示中的布尔矩阵）。您确定这就是您要填充的内容吗？

无论如何，这里有一些可能提高速度的想法：

1. 不要按值取输入向量！那是无用的复制...取他们的.data()，或者他们的.cbegin()迭代器，或者取一个span<int>参数。
2. 对目标向量使用reserve() 方法以避免多次重新分配。
3. 使用.emplace_back() 而不是.push_back() 在适当位置构造点，而不是先构造然后移动每个点。不过，老实说，编译器很可能会优化掉这些结构。
4. 将输入向量的.size() 值放入局部变量中。仅当由于某种原因编译器怀疑在函数执行过程中大小不会保持不变时，这才会有所帮助。
5. 确保将优化开关传递给编译器（例如，将 -O2 或 -O3 传递给 GCC 和 clang）。这对您来说似乎很明显，但有时很明显，您会忘记检查它是否真的完成了。

---

一些美学元素：

1. 无需对所有向量使用相同的计数器。 for(int i = 0; i < whatever; i++) 可以多次使用。
2. 不需要原始 for 循环，您可以在前两个循环中使用 for(const auto& my_element : my_vector)。第三个循环比较棘手，因为您需要索引。您可以使用std::difference() 处理迭代器，或者使用here 中描述的Python 样式枚举。
3. 您可以考虑将std::transform() 与back_emplacer 输出迭代器一起使用，而不是全部三个循环。无循环代码！这意味着在转换器 lambda 中使用 std::difference() 而不是第三个循环。

Answer 2

这包含了来自@einpoklum's answer 的建议，但也清理了代码。

std::vector<std::pair<int,int>> fast_count_segments(
    std::vector<int> const & starts, 
    std::vector<int> const & ends, 
    std::vector<int> const & points) 
{
   std::vector<std::pair<int,int>> matrix(starts.size() + ends.size() + points.size());

   auto out = std::transform(starts.cbegin(), starts.cend(),
                             matrix.begin(), 
                             [](int i) { return std::pair<int,int>{i, -1}; });

   out = std::transform(ends.cbegin(), ends.cend(),
                        out, 
                        [](int i) { return std::pair<int,int>{i, -2}; });

   int c = 0;
   std::transform(points.cbegin(), points.cend(),
                  out,
                  [&c](int i) { return std::pair<int,int>{i, c++}; });

   return matrix;
}

您甚至可以将所有转换写成一个表达式。这是否更容易阅读是非常主观的，所以我不推荐它本身。 （尝试像嵌套函数调用一样阅读它。）

std::vector<std::pair<int,int>> fast_count_segments(
    std::vector<int> const & starts, 
    std::vector<int> const & ends, 
    std::vector<int> const & points) 
{
   std::vector<std::pair<int,int>> matrix(starts.size() + ends.size() + points.size());
   int c = 0;

   std::transform(points.cbegin(), points.cend(),
        std::transform(ends.cbegin(), ends.cend(),
            std::transform(starts.cbegin(), starts.cend(),
                matrix.begin(), 
            [](int i) { return std::pair<int,int>{i, -1}; }),
        [](int i) { return std::pair<int,int>{i, -2}; }),
    [&c](int i) { return std::pair<int,int>{i, c++}; });

   return matrix;
}