N Boost 的组合 interval_set

Question

我的一项服务在 4 个不同的位置出现中断。我正在将每个位置的中断建模到 Boost ICL interval_set 中。我想知道至少 N 个位置何时发生活动中断。

因此，在 this answer 之后，我实现了一个组合算法，因此我可以通过 interval_set 个交叉点在元素之间创建组合。

当这个过程结束时，我应该有一定数量的 interval_set，它们中的每一个同时定义 N 个位置的中断，最后一步将加入它们以获得所需的全貌.

问题是我目前正在调试代码，当打印每个交叉点的时间到来时，输出文本变得疯狂（甚至当我使用gdb逐步调试时），我可以看不到它们，导致大量 CPU 使用。

我想我发送输出的内存比我应该的要多，但我看不出问题出在哪里。

这是一个 SSCCE：

#include <boost/icl/interval_set.hpp>
#include <algorithm>
#include <iostream>
#include <vector>


int main() {
    // Initializing data for test
    std::vector<boost::icl::interval_set<unsigned int> > outagesPerLocation;
    for(unsigned int j=0; j<4; j++){
        boost::icl::interval_set<unsigned int> outages;
        for(unsigned int i=0; i<5; i++){
            outages += boost::icl::discrete_interval<unsigned int>::closed(
                (i*10), ((i*10) + 5 - j));
        }
        std::cout << "[Location " << (j+1) << "] " << outages << std::endl;
        outagesPerLocation.push_back(outages);
    }

    // So now we have a vector of interval_sets, one per location. We will combine
    // them so we get an interval_set defined for those periods where at least
    // 2 locations have an outage (N)
    unsigned int simultaneusOutagesRequired = 2;  // (N)

    // Create a bool vector in order to filter permutations, and only get
    // the sorted permutations (which equals the combinations)
    std::vector<bool> auxVector(outagesPerLocation.size());
    std::fill(auxVector.begin() + simultaneusOutagesRequired, auxVector.end(), true);

    // Create a vector where combinations will be stored
    std::vector<boost::icl::interval_set<unsigned int> > combinations;

    // Get all the combinations of N elements
    unsigned int numCombinations = 0;
    do{
        bool firstElementSet = false;
        for(unsigned int i=0; i<auxVector.size(); i++){
            if(!auxVector[i]){
                if(!firstElementSet){
                    // First location, insert to combinations vector
                    combinations.push_back(outagesPerLocation[i]);
                    firstElementSet = true;
                }
                else{
                    // Intersect with the other locations
                    combinations[numCombinations] -= outagesPerLocation[i];
                }
            }
        }
        numCombinations++;
        std::cout << "[-INTERSEC-] " << combinations[numCombinations] << std::endl;  // The problem appears here
    }
    while(std::next_permutation(auxVector.begin(), auxVector.end()));

    // Get the union of the intersections and see the results
    boost::icl::interval_set<unsigned int> finalOutages;
    for(std::vector<boost::icl::interval_set<unsigned int> >::iterator
        it = combinations.begin(); it != combinations.end(); it++){
        finalOutages += *it;
    }

    std::cout << finalOutages << std::endl;
    return 0;
}

有什么帮助吗？

Answer 1

在置换循环的末尾，你写：

numCombinations++;
std::cout << "[-INTERSEC-] " << combinations[numCombinations] << std::endl;  // The problem appears here

我的调试器告诉我，在第一次迭代中，numCombinations 在增量之前是 0。但是增加它会使它超出 combinations 容器的范围（因为它只是一个元素，所以索引为 0）。

你的意思是在使用后增加它吗？有没有什么特别的理由不使用

std::cout << "[-INTERSEC-] " << combinations.back() << "\n";

或者，对于 c++03

std::cout << "[-INTERSEC-] " << combinations[combinations.size()-1] << "\n";

甚至只是：

std::cout << "[-INTERSEC-] " << combinations.at(numCombinations) << "\n";

哪个会抛出 std::out_of_range?

附带说明一下，我认为 Boost ICL 有非常更有效的方法来获得您想要的答案。让我考虑一下。如果我看到它，请 post 另一个答案。

UPDATE: Posted the show casing highlevel coding with Boost ICL

Answer 2

作为，这里有一个"highlevel"方法。

Boost ICL 容器不仅仅是 "glorified pairs of interval starting/end points" 的容器。它们旨在以普遍优化的方式实施组合、搜索业务。

所以你不必。

如果你让图书馆做它应该做的事：

using TimePoint = unsigned;
using DownTimes = boost::icl::interval_set<TimePoint>;
using Interval  = DownTimes::interval_type;
using Records   = std::vector<DownTimes>;

使用功能域类型定义需要更高层次的方法。现在，让我们问一下假设的 "business question":

What do we actually want to do with our records of per-location downtimes?

好吧，我们基本上想要

计算所有可识别的时间段和
过滤那些计数至少为 2 的那些
最后，我们想展示剩余的 "merged" 个时段。

好的，工程师：执行吧！

嗯。理货。它能有多难？

❕ The key to elegant solutions is the choice of the right datastructure

using Tally     = unsigned; // or: bit mask representing affected locations?
using DownMap   = boost::icl::interval_map<TimePoint, Tally>;

现在只是批量插入：

// We will do a tally of affected locations per time slot
DownMap tallied;
for (auto& location : records)
    for (auto& incident : location)
        tallied.add({incident, 1u});

好的，我们来筛选。我们只需要在我们的 DownMap 上起作用的谓词，对

// define threshold where at least 2 locations have an outage
auto exceeds_threshold = [](DownMap::value_type const& slot) {
    return slot.second >= 2;
};

合并时隙！

其实。我们只是创建另一个停机时间集，对吧。只是，这次不是每个位置。

数据结构的选择再次获胜：

// just printing the union of any criticals:
DownTimes merged;
for (auto&& slot : tallied | filtered(exceeds_threshold) | map_keys)
    merged.insert(slot);

举报！

std::cout << "Criticals: " << merged << "\n";

请注意，我们在任何地方都没有接近操纵数组索引、重叠或非重叠间隔、封闭或开放边界。或者，[eeeeek!] 集合元素的强力排列。

我们只是陈述了我们的目标，让图书馆来完成工作。

完整演示

Live On Coliru

#include <boost/icl/interval_set.hpp>
#include <boost/icl/interval_map.hpp>
#include <boost/range.hpp>
#include <boost/range/algorithm.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/numeric.hpp>
#include <boost/range/irange.hpp>
#include <algorithm>
#include <iostream>
#include <vector>

using TimePoint = unsigned;
using DownTimes = boost::icl::interval_set<TimePoint>;
using Interval  = DownTimes::interval_type;
using Records   = std::vector<DownTimes>;

using Tally     = unsigned; // or: bit mask representing affected locations?
using DownMap   = boost::icl::interval_map<TimePoint, Tally>;

// Just for fun, removed the explicit loops from the generation too. Obviously,
// this is bit gratuitous :)
static DownTimes generate_downtime(int j) {
    return boost::accumulate(
            boost::irange(0, 5),
            DownTimes{},
            [j](DownTimes accum, int i) { return accum + Interval::closed((i*10), ((i*10) + 5 - j)); }
        );
}

int main() {
    // Initializing data for test
    using namespace boost::adaptors;
    auto const records = boost::copy_range<Records>(boost::irange(0,4) | transformed(generate_downtime));

    for (auto location : records | indexed()) {
        std::cout << "Location " << (location.index()+1) << " " << location.value() << std::endl;
    }

    // We will do a tally of affected locations per time slot
    DownMap tallied;
    for (auto& location : records)
        for (auto& incident : location)
            tallied.add({incident, 1u});

    // We will combine them so we get an interval_set defined for those periods
    // where at least 2 locations have an outage
    auto exceeds_threshold = [](DownMap::value_type const& slot) {
        return slot.second >= 2;
    };

    // just printing the union of any criticals:
    DownTimes merged;
    for (auto&& slot : tallied | filtered(exceeds_threshold) | map_keys)
        merged.insert(slot);

    std::cout << "Criticals: " << merged << "\n";
}

打印

Location 1 {[0,5][10,15][20,25][30,35][40,45]}
Location 2 {[0,4][10,14][20,24][30,34][40,44]}
Location 3 {[0,3][10,13][20,23][30,33][40,43]}
Location 4 {[0,2][10,12][20,22][30,32][40,42]}
Criticals: {[0,4][10,14][20,24][30,34][40,44]}

N Boost 的组合 interval_set

Combinations of N Boost interval_set

c++

algorithm

boost

intervals

boost-icl

所以你不必。

完整演示