处理设定间隔的算法

Question

实现一个需要在 C++ 中跟踪设置间隔的类的最佳方法是什么？我希望利用现有的 STL 或 Boost 库，但除了使用标准容器之外，我不得不求助于手动实现算法，这非常棘手，而且我不得不以牺牲一些性能为代价来简化它。最后期限。一定有更好的办法。

例如，我需要以下类型的行为：

class SubRange
{
public:
SubRange(const T& lower_bound, const T& upper_bound);
...
};

Subrange r1(1,3);
Subrange r2(5,6);
Subrange r3(6,9);

Subrange tot = r1+r2+r3;
cout << tot;  //displays (1,3) (5,9)

Subrange gaps = SubRange(1,9) - tot;
cout << gaps; // displays (4,4)

注意 子范围由下限和上限组成，表示从下限到上限的连续元素集，其中两个边界都包含在集合中。该集合从下限开始构造并递增（运算符++）直到达到上限。

我查看了处理区间算术的 Boost Interval，但似乎并没有解决我的问题，但是文档对我来说并不容易理解。如果有人认为这会有所帮助，那么请他们告诉我如何实现上述示例。

对于好奇的人。我的用例是代理服务器中的缓存算法，它需要跟踪客户端请求的数据的时间间隔，并且最好只从服务器请求那些尚未缓存的时间间隔部分。如果客户端 A 请求从 2016 年 1 月 1 日到 2016 年 1 月 3 日的数据，客户端 B 请求从 2016 年 1 月 5 日到 2016 年 1 月 6 日的数据，客户端 C 请求从 2016 年 1 月 6 日到 9 日的数据-2016 年 1 月，然后如果客户端 D 请求从 2016 年 1 月 1 日到 2016 年 1 月 9 日的数据，那么代理应该只向服务器请求 2016 年 1 月 4 日，因为其余日期已经被缓存。

Answer 1

您可以使用Boost Interval Container Library (ICL) 来完成此任务：

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

int main()
{
    using IntervalSet = boost::icl::interval_set<int>;
    using Interval = boost::icl::interval<int>;

    IntervalSet set;

    set.insert(Interval::closed(1,3));
    set.insert(Interval::closed(5,6));
    set.insert(Interval::closed(6,9));

    std::cout << set << std::endl;

    IntervalSet total;
    total.insert(Interval::closed(1,9));

    std::cout << total << std::endl;

    IntervalSet diff_set = total - set;
    std::cout << diff_set << std::endl;

    for (auto it : diff_set)
    {
        // convert (possibly) open interval into closed
        std::cout << "[" << boost::icl::first(it) << "," << boost::icl::last(it) << "]"<< std::endl;
    }
}

输出：

{[1,3][5,9]}
{[1,9]}
{(3,5)}
[4,4]

live example

Answer 2

试试这个它对我有用
注意：您可以使用 min 和 max 来获取最大子间隔。

    #include <iostream>
    #include <vector>

    using namespace std;

    struct val{
        int start = 0;
        int end = 0;
    };
    void FindSubSortbyStart(val *x,unsigned long n){
        for(int i = 1;i < n;i++)
            for(int j = i;j > 0;j--)
                if(x[j].start < x[j - 1].start )
                    swap(x[j],x[j-1]);
                else
                    break;
    }
    void FindSub(val *x,unsigned long n){
        vector<val> subval;

        int min = x[0].start;
        int max = x[0].end;

        for(int i = 1;i <n;i++){
            if(max  + 1>= x[i].start){
                if(x[i].end >= max)
                    max = x[i].end;
            }else{

                val temp;

                temp.start = max + 1;
                temp.end = x[i].start - 1;

                max = x[i].end;
                min = x[i].start;

                subval.push_back(temp);

                cout << subval[subval.size() - 1].start << "\t"<< subval[subval.size() - 1].end << endl;
            }
        }
    }

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

        unsigned long n = 3;

        val *x = new val[n];

        x[0].start = 1;
        x[0].end = 3;

        x[1].start = 5;
        x[1].end = 5;

        x[2].start = 7;
        x[2].end = 9;

        FindSubSortbyStart(x,n);
        FindSub(x,n);

        return 0;
    }