C++ Boost不交集

我需要创建一个类型为

dataum

的不相交集

向量中的所有数据如下所示

vector<dataum> S;
S.push_back( dataum(0,0) );
S.push_back( dataum(0,1) );
S.push_back( dataum(0,2) );
 .
 .

向量S；
S.push_back（dataum（0,0））；
S.push_-back（dataum（0,1））；
S.push_-back（dataum（0,2））；
.
.

然后我创建不相交的集合

std::vector<int>  rank (100);
std::vector<dataum>  parent (100);
boost::disjoint_sets<int*,dataum*> ds(&rank[0], &parent[0]);

for( int i=0 ; i<S.size() ; i++ )
{
    ds.make_set( S[i] );
}

std:：向量秩（100）；
std：：载体亲本（100）；
boost:：不相交的_集ds（&rank[0]，&parent[0]）；
对于（int i=0；i，文件中规定


Rank
必须是
ReadWritePropertyMap
的模型，具有整数值类型，键类型等于集合的元素类型

Parent
必须是
ReadWritePropertyMap
的模型，并且键和值类型必须与集合的元素类型相同

在您之前的问题中，我在评论中发布了以下示例代码：

在看了（对我来说是新的）
不相交的集合*
类之后，我认为它们不能迭代集合的成员。它们就像从元素到集合代表的单向映射。如果有帮助的话：–sehe

这是为想象中的
dataum
类型重新制作的：

struct dataum { 
    int x,y; 
    bool operator< (const dataum& o) const { return tie(x,y)  < tie(o.x,o.y); } 
    bool operator==(const dataum& o) const { return tie(x,y) == tie(o.x,o.y); } 
    bool operator!=(const dataum& o) const { return tie(x,y) != tie(o.x,o.y); } 
};

其机制可以在中找到，这是一个非常强大的通用数据结构抽象层，主要用于Boost图形库。它功能强大，但我不能说它对用户友好

以下是Coliru现场的完整演示

#include <boost/pending/disjoint_sets.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <iostream>
#include <map>
#include <cassert>

using namespace boost;
struct dataum { 
    int x,y; 
    bool operator< (const dataum& o) const { return tie(x,y)  < tie(o.x,o.y); } 
    bool operator==(const dataum& o) const { return tie(x,y) == tie(o.x,o.y); } 
    bool operator!=(const dataum& o) const { return tie(x,y) != tie(o.x,o.y); } 
};

int main() {
    std::vector<dataum> S { {0,0}, {0,1}, {0,2} };

    std::map<dataum,int> rank;
    std::map<dataum,dataum> parent;

    boost::disjoint_sets<
        associative_property_map<std::map<dataum,int>>,
        associative_property_map<std::map<dataum,dataum>> > ds(
                make_assoc_property_map(rank),
                make_assoc_property_map(parent));

    for(auto i=0ul; i<S.size(); i++)
        ds.make_set(S[i]);

    assert((ds.count_sets(S.begin(), S.end()) == 3));
    assert((ds.find_set(dataum{0,2}) == dataum{0,2}));
    assert((ds.find_set(dataum{0,1}) == dataum{0,1}));

    ds.union_set(dataum{0,2},dataum{0,1});

    assert((ds.count_sets(S.begin(), S.end()) == 2));
    assert((ds.find_set(dataum{0,2}) == dataum{0,1}));
    assert((ds.find_set(dataum{0,1}) == dataum{0,1}));

    std::cout << "done";
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间boost；
结构数据{
int x，y；
bool算子<（const dataum&o）const{return tie（x，y）ds(
制作相关属性地图（等级），
制作关联属性映射（父级）；
对于（自动i=0ul；i）什么不起作用。你期望什么？你看到了什么？刚刚编辑了问题。你如何判断结果不正确？
#include <boost/pending/disjoint_sets.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <iostream>
#include <map>
#include <cassert>

using namespace boost;
struct dataum { 
    int x,y; 
    bool operator< (const dataum& o) const { return tie(x,y)  < tie(o.x,o.y); } 
    bool operator==(const dataum& o) const { return tie(x,y) == tie(o.x,o.y); } 
    bool operator!=(const dataum& o) const { return tie(x,y) != tie(o.x,o.y); } 
};

int main() {
    std::vector<dataum> S { {0,0}, {0,1}, {0,2} };

    std::map<dataum,int> rank;
    std::map<dataum,dataum> parent;

    boost::disjoint_sets<
        associative_property_map<std::map<dataum,int>>,
        associative_property_map<std::map<dataum,dataum>> > ds(
                make_assoc_property_map(rank),
                make_assoc_property_map(parent));

    for(auto i=0ul; i<S.size(); i++)
        ds.make_set(S[i]);

    assert((ds.count_sets(S.begin(), S.end()) == 3));
    assert((ds.find_set(dataum{0,2}) == dataum{0,2}));
    assert((ds.find_set(dataum{0,1}) == dataum{0,1}));

    ds.union_set(dataum{0,2},dataum{0,1});

    assert((ds.count_sets(S.begin(), S.end()) == 2));
    assert((ds.find_set(dataum{0,2}) == dataum{0,1}));
    assert((ds.find_set(dataum{0,1}) == dataum{0,1}));

    std::cout << "done";
}