C++11标准模板（STL）- 算法库 - 类似 std::partial_sum，第 i 个和中包含第 i 个输入 -（std::inclusive_scan）

于 2024-08-17 22:12:09 发布
阅读量728 收藏 28
点赞数 30
分类专栏： # 数值运算 文章标签： c++ 开发语言 STL inclusive_scan 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/141287792
版权

算法库

算法库提供大量用途的函数（例如查找、排序、计数、操作），它们在元素范围上操作。注意范围定义为 [first, last) ，其中 last 指代要查询或修改的最后元素的后一个元素。

类似 std::partial_sum，第 i 个和中包含第 i 个输入

std::inclusive_scan
template< class InputIt, class OutputIt >

OutputIt inclusive_scan( InputIt first,

                         InputIt last, OutputIt d_first );		(1)(C++17 起)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >

ForwardtIt2 inclusive_scan( ExecutionPolicy&& policy, ForwardIt1 first,

                            ForwardIt1 last, ForwardIt2 d_first );		(2)(C++17 起)
template< class InputIt, class OutputIt, class BinaryOperation >

OutputIt inclusive_scan( InputIt first, InputIt last,

                         OutputIt d_first, BinaryOperation binary_op );		(3)(C++17 起)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,

          class BinaryOperation >
ForwardIt2 inclusive_scan( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last,

                           ForwardIt2 d_first, BinaryOperation binary_op );		(4)(C++17 起)
1

template< class InputIt, class OutputIt, class BinaryOperation, class T >
OutputIt inclusive_scan( InputIt first, InputIt last, OutputIt d_first,

                         BinaryOperation binary_op, T init );		(5)(C++17 起)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2,

          class BinaryOperation, class T >
ForwardIt2 inclusive_scan( ExecutionPolicy&& policy,
                           ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first,

                           BinaryOperation binary_op, T init );

用 binary_op （或对于重载 (1-2) 则是 std::plus<>() ）对范围 [first, last) 计算包含性前缀和运算，以 init 为初始值（若提供），并将结果写入从 d_first 开始的范围。“包含性”意味着第 i 个输入元素包含于第 i 个和。

正式而言，通过每个 [d_first, d_first + (last - first)) 中的迭代器 i ，以下列值赋值：

  • 重载 (1-4) 为，对于每个区间 [first, first + (i - d_first + 1)) 中的 j ， *j... 在 binary_op 上的广义非交换和
  • 重载 (5-6) 为，对于每个区间 [first, first + (i - d_first + 1)) 中的 j ， init, *j... 在 binary_op 上的广义非交换和

其中广义非交换和 GNSUM(op, a
1, ..., a
N) 定义如下：

  • 若 N=1 ，则为 a
    1
  • 若 N > 1 ，则为 op(GNSUM(op, a
    1, ..., a
    K), GNSUM(op, a
    M, ..., a
    N)) ，对于任何 1 < K+1 = M ≤ N 中的 K

换言之，和运算可能以任意顺序进行，而且若 binary_op 非结合，则行为是非确定的。

重载 (2,4,6) 按照 policy 执行。此重载仅若std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> 为 true 才参与重载决议。

binary_op 不应非话法范围 [first, last) 或 [d_first, d_first + (last - first)) 中的迭代器（含尾迭代器）或子范围，亦不应修改其中的元素。否则行为未定义。

参数

first, last-要求和的元素范围
d_first-目标范围的起始，可以等于 first
policy-所用的执行策略。细节见执行策略。
init-初始值（可选）
binary_op-将应用到解引用输入迭代器结果、其他 binary_op 结果和 init （若提供）的二元函数对象 (FunctionObject) 。
类型要求
- InputIt 必须满足遗留输入迭代器 (LegacyInputIterator) 的要求。
- OutputIt 必须满足遗留输出迭代器 (LegacyOutputIterator) 的要求。
- ForwardIt1 必须满足遗留向前迭代器 (LegacyForwardIterator) 的要求。且若不提供 init ，则 ForwardIt1 的 value_type 必须为可移动构造 (MoveConstructible) 且 binary_op(*first, *first) 必须可转换到 ForwardIt1 的 value_type
- ForwardIt2 必须满足遗留向前迭代器 (LegacyForwardIterator) 的要求。
- T （若提供 init ） 必须满足可移动构造 (MoveConstructible) 的要求。binary_op(init, *first) 、 binary_op(init, init) 及 binary_op(*first, *first) 都必须能转换到 T

返回值

指向最后写入元素后一位的迭代器。

复杂度

O(last - first) 次应用二元运算

异常

拥有名为 ExecutionPolicy 的模板形参的重载按下列方式报告错误：

  • 若作为算法一部分调用的函数的执行抛出异常，且 ExecutionPolicy 为标准策略之一，则调用 std::terminate 。对于任何其他 ExecutionPolicy ，行为是实现定义的。
  • 若算法无法分配内存，则抛出 std::bad_alloc 。

 

调用示例

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <time.h>
#include <random>
#include <vector>
#include <cassert>

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }

    friend Cell operator+(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x += rcell.x;
        cell.y += rcell.y;
        return cell;
    }

    friend Cell operator-(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x -= rcell.x;
        cell.y -= rcell.y;
        return cell;
    }

    friend Cell operator*(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x *= rcell.x;
        cell.y *= rcell.y;
        return cell;
    }

    friend Cell operator/(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x /= rcell.x;
        cell.y /= rcell.y;
        return cell;
    }

    friend Cell operator%(const Cell &lcell, const Cell &rcell)
    {
        Cell cell = lcell;
        cell.x %= rcell.x;
        cell.y %= rcell.y;
        return cell;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

namespace std
{
template<typename InputIt, typename OutputIt, typename T, typename BinaryOperation>
OutputIt inclusive_scan(InputIt first, InputIt last, OutputIt d_first, T init, BinaryOperation binary_op)
{
    T temp = init;
    for (; first != last; ++first, ++d_first)
    {
        temp = binary_op(temp, *first);
        *d_first = temp;
    }
    return d_first;
}
}

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return cell;
    };

    auto generate10 = []()
    {
        int n = std::rand() % 10 + 1;
        Cell cell{n, n};
        return cell;
    };

    //3) 构造拥有 count 个有值 value 的元素的容器。
    std::vector<Cell> vector1(8, generate());
    std::generate(vector1.begin(), vector1.end(), generate);
    std::sort(vector1.begin(), vector1.end());
    std::cout << "vector1:  ";
    std::copy(vector1.begin(), vector1.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::vector<Cell> vector2(vector1.size(), Cell{101, 101});
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::vector<Cell> vector3(8, generate10());
    std::generate(vector3.begin(), vector3.end(), generate10);
    std::sort(vector3.begin(), vector3.end());
    std::cout << "vector3:  ";
    std::copy(vector3.begin(), vector3.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::inclusive_scan(vector1.begin(), vector1.end(), vector2.begin(), *vector1.begin(), std::plus<Cell>());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    std::inclusive_scan(vector1.begin(), vector1.end(), vector2.begin(), *vector1.begin(), std::minus<Cell>());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    std::inclusive_scan(vector3.begin(), vector3.end(), vector2.begin(), *vector3.begin(), std::multiplies<Cell>());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    std::inclusive_scan(vector1.begin(), vector1.end(), vector2.begin(), Cell{1024, 1024}, std::divides<Cell>());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    std::inclusive_scan(vector1.begin(), vector1.end(), vector2.begin(), Cell{1024, 1024}, std::modulus<Cell>());
    std::cout << "vector2:  ";
    std::copy(vector2.begin(), vector2.end(), std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;

    return 0;
}

输出

vector1:  {110,110} {112,112} {114,114} {114,114} {117,117} {118,118} {119,119} {119,119}
vector2:  {101,101} {101,101} {101,101} {101,101} {101,101} {101,101} {101,101} {101,101}
vector3:  {1,1} {2,2} {5,5} {5,5} {6,6} {6,6} {9,9} {9,9}
vector2:  {220,220} {332,332} {446,446} {560,560} {677,677} {795,795} {914,914} {1033,1033}

vector2:  {0,0} {-112,-112} {-226,-226} {-340,-340} {-457,-457} {-575,-575} {-694,-694} {-813,-813}

vector2:  {1,1} {2,2} {10,10} {50,50} {300,300} {1800,1800} {16200,16200} {145800,145800}

vector2:  {9,9} {0,0} {0,0} {0,0} {0,0} {0,0} {0,0} {0,0}

vector2:  {34,34} {34,34} {34,34} {34,34} {34,34} {34,34} {34,34} {34,34}

繁星璀璨G
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值