Question

我需要在std::set<Edge>上有效地定义排序。 Edge表示图形中的边（不是多图）。

class Edge
    {
        friend class Graph;
        string from;
        string to;
        EdgeInfo edge_length; //constructor is `EdgeInfo(int edge_length)`
    public:
        bool operator==(const Edge& rhs) {
            return (from==rhs.from && to==rhs.to);               
        }
    };

问题是要有效地找到

std::set<Edge>是否包含给定“from”和“to”
从给定的“from”到某些“to”的边缘，其中“to”不在给定的set<string>

使用std::set.count()和std::set.find()。我需要以某种方式在std::set上定义适当的顺序。这可能吗？

编辑：我认为我应该使用map或multimap代替set。最后我使用了map。解决方案的灵感来自于@ tom建议使用map of maps。

解：

typedef int EdgeInfo; //just for the sake of this example (EdgeInfo can be length,price,...) 
map< string, map<string, EdgeInfo> > edges;

std::set<Edge>是否包含给定“from”和的边缘 “到”

if (edges.count(from)!=0 && edges[from].count(to)!=0) {
        return true; 
}

或者如果函数是const

if (edges.count(from)!=0 && ((edges.find(top.second))->second).count(to)!=0) {
        return true; 
}

从给定的“from”到“to”的边缘，其中“to”不在里面给定的集合

如果函数是const

//if there are any edges from "from"
if (edges.count(from)!=0) {  

    //iterate over all edges from "from"
    for (map<string,EdgeInfo>::const_iterator
                 edge=((edges.find(from))->second).begin();
                 edge!=((edges.find(from))->second).end();
                 ++edge) {

        //if the edge goes to some vertex V that has not been discarded
        if (discarded.count(edge->first)==0) { //edge->first means "to"

Answer 1

邻接清单

map< string, set<string> > edges;
// edges["a"] is the set of all nodes that can be reached from "a"

// O(log n)
bool exists(string from, string to)
{
    return edges[from].count(to) > 0;
}

// Ends of edges that start at 'from' and do not finish in 'exclude', O(n)
set<string> edgesExcept(string from, set<string>& exclude)
{
    set<string>& fromSet = edges[from];
    set<string> results;
    // set_difference from <algorithm>, inserter from <iterator>
    set_difference(fromSet.begin(), fromSet.end(),
            exclude.begin(), exclude.end(),
            inserter(results, results.end()));
    return results;
}

邻接矩阵

map< string, map<string, Edge*> > edgesMatrix;
// edgesMatrix["a"]["b"] is the Edge* from "a" to "b"
// e.g. Edge* e = new Edge(...); edgesMatrix[e->from][e->to] = e;

bool exists(string from, string to)
{
    return edgesMatrix[from].count(to) > 0;
}

vector<Edge*> edgesExcept(string from, set<string>& exclude)
{
    map<string, Edge*>& all = edgesMatrix[from];
    vector<Edge*> results;

    map<string, Edge*>::iterator allIt = all.begin();
    set<string>::iterator excludeIt = exclude.begin();

    while (allIt != all.end())
    {
        while (excludeIt != exclude.end() && *excludeIt < allIt->first)
        {
            ++excludeIt;
        }

        if (excludeIt == exclude.end() || allIt->first < *excludeIt)
        {
            results.push_back(allIt->second);
        }
        ++allIt;
    }

    return results;
}

一个有序集

这更符合OP的原始要求，但我觉得它比其他选项更加丑陋。
我只是为了完整而包含了这个。

// sorted first by 'from', then by 'to'
class Edge {
    // ...
public:
    bool operator<(const Edge& r) const {
        return from < r.from || (from == r.from && to < r.to);
    }
};

set<Edge> edges;

bool exists(string from, string to) {
    Edge temp(from, to, -1);
    return edges.count(temp) > 0;
}

set<Edge> edgesExcept(string from, set<string>& exclude) {
    Edge first = Edge(from, "", -1); // ugly hack: "" sorts before other to's
    set<Edge> results;

    set<Edge>::iterator allIt = edges.lower_bound(first);
    set<string>::iterator excludeIt = exclude.begin();

    while (allIt != edges.end() && allIt->from == from) {
        while (excludeIt != exclude.end() && *excludeIt < allIt->to) {
            ++excludeIt;
        }
        if (excludeIt == exclude.end() || allIt->to < *excludeIt) {
            results.insert(results.end(), *allIt);
        }
        ++allIt;
    }
    return results;
}

`edgesExcept()`

的说明

这是伪代码版本：

for each edge e in edges_of_interest (in sorted order)
    get rid of edges in exclude_edges that sort before e
    if e is equal to the first edge in exclude_edges
        e is in exclude_edges, so
        ignore e (i.e. do nothing)
    otherwise
        e is not in exclude_edges, so
        add e to good_edges

而不是实际删除与exclude_edges不再相关的边，C ++版本使用迭代器来记住exclude_edges中哪些边不再相关（小于所有感兴趣边缘的边）还有待检查）。一旦exclude_edges中小于e的所有边缘都被删除/跳过，检查e中是否出现exclude_edges只需将其与第一个进行比较即可exclude_edges的（最小）元素。

Answer 2

出于什么原因你应该使用多重图来完成这种工作？我认为地图已经足够了，如果我理解得很好，你就不需要在图表上保留相同的节点。

如果您决定使用地图，则很容易找到现有边缘，也是您的第二个问题。您只需搜索密钥并迭代地图即可。使用Set，元素以随机顺序插入，因此，这意味着您的搜索需要很长时间（O（N）。如果您将元素存储在地图中（我认为最好的方法是使用＆＃34;来自＆＃34;作为键），插入将被订购，您的搜索使用时间为O（Log n）

如果您需要修改图表中的连接，如果它们位于集合中，则无法修改集合元素，您可以在地图中修改。

实现一个有效的容器，用于在图形中存储边缘

2 个答案:

邻接清单

邻接矩阵

一个有序集

`edgesExcept()`